diff options
| author |  dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> | 2023-06-01 22:20:16 +0100 |
|---|---|---|
| committer |  GitHub <noreply@github.com> | 2023-06-01 22:20:16 +0100 |
| commit | 55aacaf4b07c1921061245cbaa3d307e97cf3c29 (patch) | |
| tree | d969c5d9728566de1e794e19c5b19d3b660f790e | |
| parent | [chore/frontend] refactor header templating, add apple-touch-icon (#1850) (diff) | |
| download | gotosocial-55aacaf4b07c1921061245cbaa3d307e97cf3c29.tar.xz | |
[chore]: Bump github.com/gin-gonic/gin from 1.9.0 to 1.9.1 (#1855)
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
138 files changed, 26758 insertions, 24699 deletions
@@ -24,7 +24,7 @@ require ( github.com/gin-contrib/cors v1.4.0 github.com/gin-contrib/gzip v0.0.6 github.com/gin-contrib/sessions v0.0.5 - github.com/gin-gonic/gin v1.9.0 + github.com/gin-gonic/gin v1.9.1 github.com/go-fed/httpsig v1.1.0 github.com/go-playground/form/v4 v4.2.0 github.com/go-playground/validator/v10 v10.14.0 @@ -82,7 +82,7 @@ require ( codeberg.org/gruf/go-maps v1.0.3 // indirect codeberg.org/gruf/go-pools v1.1.0 // indirect github.com/aymerick/douceur v0.2.0 // indirect - github.com/bytedance/sonic v1.8.0 // indirect + github.com/bytedance/sonic v1.9.1 // indirect github.com/cenkalti/backoff/v4 v4.2.1 // indirect github.com/chenzhuoyu/base64x v0.0.0-20221115062448-fe3a3abad311 // indirect github.com/cilium/ebpf v0.9.1 // indirect @@ -108,7 +108,7 @@ require ( github.com/go-playground/locales v0.14.1 // indirect github.com/go-playground/universal-translator v0.18.1 // indirect github.com/go-xmlfmt/xmlfmt v0.0.0-20211206191508-7fd73a941850 // indirect - github.com/goccy/go-json v0.10.0 // indirect + github.com/goccy/go-json v0.10.2 // indirect github.com/godbus/dbus/v5 v5.0.4 // indirect github.com/golang-jwt/jwt v3.2.2+incompatible // indirect github.com/golang/geo v0.0.0-20210211234256-740aa86cb551 // indirect @@ -132,13 +132,13 @@ require ( github.com/klauspost/cpuid/v2 v2.2.4 // indirect github.com/leodido/go-urn v1.2.4 // indirect github.com/magiconair/properties v1.8.7 // indirect - github.com/mattn/go-isatty v0.0.18 // indirect + github.com/mattn/go-isatty v0.0.19 // indirect github.com/minio/md5-simd v1.1.2 // indirect github.com/minio/sha256-simd v1.0.1 // indirect github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect github.com/modern-go/reflect2 v1.0.2 // indirect github.com/opencontainers/runtime-spec v1.0.2 // indirect - github.com/pelletier/go-toml/v2 v2.0.6 // indirect + github.com/pelletier/go-toml/v2 v2.0.8 // indirect github.com/pkg/errors v0.9.1 // indirect github.com/pmezard/go-difflib v1.0.0 // indirect github.com/quasoft/memstore v0.0.0-20191010062613-2bce066d2b0b // indirect @@ -154,7 +154,7 @@ require ( github.com/tdewolff/parse/v2 v2.6.5 // indirect github.com/tmthrgd/go-hex v0.0.0-20190904060850-447a3041c3bc // indirect github.com/twitchyliquid64/golang-asm v0.15.1 // indirect - github.com/ugorji/go/codec v1.2.9 // indirect + github.com/ugorji/go/codec v1.2.11 // indirect github.com/uptrace/opentelemetry-go-extra/otelsql v0.1.21 // indirect github.com/vmihailenco/msgpack/v5 v5.3.5 // indirect github.com/vmihailenco/tagparser/v2 v2.0.0 // indirect @@ -162,7 +162,7 @@ require ( go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.14.0 // indirect go.opentelemetry.io/otel/metric v0.37.0 // indirect go.opentelemetry.io/proto/otlp v0.19.0 // indirect - golang.org/x/arch v0.0.0-20210923205945-b76863e36670 // indirect + golang.org/x/arch v0.3.0 // indirect golang.org/x/mod v0.10.0 // indirect golang.org/x/sys v0.8.0 // indirect golang.org/x/tools v0.6.0 // indirect @@ -102,8 +102,8 @@ github.com/aymerick/douceur v0.2.0/go.mod h1:wlT5vV2O3h55X9m7iVYN0TBM0NH/MmbLnd3 github.com/buckket/go-blurhash v1.1.0 h1:X5M6r0LIvwdvKiUtiNcRL2YlmOfMzYobI3VCKCZc9Do= github.com/buckket/go-blurhash v1.1.0/go.mod h1:aT2iqo5W9vu9GpyoLErKfTHwgODsZp3bQfXjXJUxNb8= github.com/bytedance/sonic v1.5.0/go.mod h1:ED5hyg4y6t3/9Ku1R6dU/4KyJ48DZ4jPhfY1O2AihPM= -github.com/bytedance/sonic v1.8.0 h1:ea0Xadu+sHlu7x5O3gKhRpQ1IKiMrSiHttPF0ybECuA= -github.com/bytedance/sonic v1.8.0/go.mod h1:i736AoUSYt75HyZLoJW9ERYxcy6eaN6h4BZXU064P/U= +github.com/bytedance/sonic v1.9.1 h1:6iJ6NqdoxCDr6mbY8h18oSO+cShGSMRGCEo7F2h0x8s= +github.com/bytedance/sonic v1.9.1/go.mod h1:i736AoUSYt75HyZLoJW9ERYxcy6eaN6h4BZXU064P/U= github.com/cenkalti/backoff/v4 v4.2.1 h1:y4OZtCnogmCPw98Zjyt5a6+QwPLGkiQsYW5oUqylYbM= github.com/cenkalti/backoff/v4 v4.2.1/go.mod h1:Y3VNntkOUPxTVeUxJ/G5vcM//AlwfmyYozVcomhLiZE= github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU= @@ -201,8 +201,8 @@ github.com/gin-contrib/sessions v0.0.5/go.mod h1:vYAuaUPqie3WUSsft6HUlCjlwwoJQs9 github.com/gin-contrib/sse v0.1.0 h1:Y/yl/+YNO8GZSjAhjMsSuLt29uWRFHdHYUb5lYOV9qE= github.com/gin-contrib/sse v0.1.0/go.mod h1:RHrZQHXnP2xjPF+u1gW/2HnVO7nvIa9PG3Gm+fLHvGI= github.com/gin-gonic/gin v1.8.1/go.mod h1:ji8BvRH1azfM+SYow9zQ6SZMvR8qOMZHmsCuWR9tTTk= -github.com/gin-gonic/gin v1.9.0 h1:OjyFBKICoexlu99ctXNR2gg+c5pKrKMuyjgARg9qeY8= -github.com/gin-gonic/gin v1.9.0/go.mod h1:W1Me9+hsUSyj3CePGrd1/QrKJMSJ1Tu/0hFEH89961k= +github.com/gin-gonic/gin v1.9.1 h1:4idEAncQnU5cB7BeOkPtxjfCSye0AAm1R0RVIqJ+Jmg= +github.com/gin-gonic/gin v1.9.1/go.mod h1:hPrL7YrpYKXt5YId3A/Tnip5kqbEAP+KLuI3SUcPTeU= github.com/go-errors/errors v1.0.1/go.mod h1:f4zRHt4oKfwPJE5k8C9vpYG+aDHdBFUsgrm6/TyX73Q= github.com/go-errors/errors v1.0.2/go.mod h1:psDX2osz5VnTOnFWbDeWwS7yejl+uV3FEWEp4lssFEs= github.com/go-errors/errors v1.1.1/go.mod h1:psDX2osz5VnTOnFWbDeWwS7yejl+uV3FEWEp4lssFEs= @@ -239,8 +239,8 @@ github.com/go-test/deep v1.0.8 h1:TDsG77qcSprGbC6vTN8OuXp5g+J+b5Pcguhf7Zt61VM= github.com/go-xmlfmt/xmlfmt v0.0.0-20211206191508-7fd73a941850 h1:PSPmmucxGiFBtbQcttHTUc4LQ3P09AW+ldO2qspyKdY= github.com/go-xmlfmt/xmlfmt v0.0.0-20211206191508-7fd73a941850/go.mod h1:aUCEOzzezBEjDBbFBoSiya/gduyIiWYRP6CnSFIV8AM= github.com/goccy/go-json v0.9.7/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MGFi0w8I= -github.com/goccy/go-json v0.10.0 h1:mXKd9Qw4NuzShiRlOXKews24ufknHO7gx30lsDyokKA= -github.com/goccy/go-json v0.10.0/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MGFi0w8I= +github.com/goccy/go-json v0.10.2 h1:CrxCmQqYDkv1z7lO7Wbh2HN93uovUHgrECaO5ZrCXAU= +github.com/goccy/go-json v0.10.2/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MGFi0w8I= github.com/godbus/dbus/v5 v5.0.4 h1:9349emZab16e7zQvpmsbtjc18ykshndd8y2PG3sgJbA= github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA= github.com/golang-jwt/jwt v3.2.1+incompatible/go.mod h1:8pz2t5EyA70fFQQSrl6XZXzqecmYZeUEB8OUGHkxJ+I= @@ -440,8 +440,8 @@ github.com/mattn/go-isatty v0.0.5/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hd github.com/mattn/go-isatty v0.0.7/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s= github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU= github.com/mattn/go-isatty v0.0.14/go.mod h1:7GGIvUiUoEMVVmxf/4nioHXj79iQHKdU27kJ6hsGG94= -github.com/mattn/go-isatty v0.0.18 h1:DOKFKCQ7FNG2L1rbrmstDN4QVRdS89Nkh85u68Uwp98= -github.com/mattn/go-isatty v0.0.18/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= +github.com/mattn/go-isatty v0.0.19 h1:JITubQf0MOLdlGRuRq+jtsDlekdYPia9ZFsB8h/APPA= +github.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= github.com/mattn/go-sqlite3 v2.0.3+incompatible h1:gXHsfypPkaMZrKbD5209QV9jbUTJKjyR5WD3HYQSd+U= github.com/microcosm-cc/bluemonday v1.0.24 h1:NGQoPtwGVcbGkKfvyYk1yRqknzBuoMiUrO6R7uFTPlw= github.com/microcosm-cc/bluemonday v1.0.24/go.mod h1:ArQySAMps0790cHSkdPEJ7bGkF2VePWH773hsJNSHf8= @@ -476,8 +476,8 @@ github.com/opencontainers/runtime-spec v1.0.2/go.mod h1:jwyrGlmzljRJv/Fgzds9SsS/ github.com/orcaman/writerseeker v0.0.0-20200621085525-1d3f536ff85e h1:s2RNOM/IGdY0Y6qfTeUKhDawdHDpK9RGBdx80qN4Ttw= github.com/orcaman/writerseeker v0.0.0-20200621085525-1d3f536ff85e/go.mod h1:nBdnFKj15wFbf94Rwfq4m30eAcyY9V/IyKAGQFtqkW0= github.com/pelletier/go-toml/v2 v2.0.1/go.mod h1:r9LEWfGN8R5k0VXJ+0BkIe7MYkRdwZOjgMj2KwnJFUo= -github.com/pelletier/go-toml/v2 v2.0.6 h1:nrzqCb7j9cDFj2coyLNLaZuJTLjWjlaz6nvTvIwycIU= -github.com/pelletier/go-toml/v2 v2.0.6/go.mod h1:eumQOmlWiOPt5WriQQqoM5y18pDHwha2N+QD+EUNTek= +github.com/pelletier/go-toml/v2 v2.0.8 h1:0ctb6s9mE31h0/lhu+J6OPmVeDxJn+kYnJc2jZR9tGQ= +github.com/pelletier/go-toml/v2 v2.0.8/go.mod h1:vuYfssBdrU2XDZ9bYydBu6t+6a6PYNcZljzZR9VXg+4= github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA= github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= @@ -588,8 +588,8 @@ github.com/twitchyliquid64/golang-asm v0.15.1 h1:SU5vSMR7hnwNxj24w34ZyCi/FmDZTkS github.com/twitchyliquid64/golang-asm v0.15.1/go.mod h1:a1lVb/DtPvCB8fslRZhAngC2+aY1QWCk3Cedj/Gdt08= github.com/ugorji/go v1.2.7/go.mod h1:nF9osbDWLy6bDVv/Rtoh6QgnvNDpmCalQV5urGCCS6M= github.com/ugorji/go/codec v1.2.7/go.mod h1:WGN1fab3R1fzQlVQTkfxVtIBhWDRqOviHU95kRgeqEY= -github.com/ugorji/go/codec v1.2.9 h1:rmenucSohSTiyL09Y+l2OCk+FrMxGMzho2+tjr5ticU= -github.com/ugorji/go/codec v1.2.9/go.mod h1:UNopzCgEMSXjBc6AOMqYvWC1ktqTAfzJZUZgYf6w6lg= +github.com/ugorji/go/codec v1.2.11 h1:BMaWp1Bb6fHwEtbplGBGJ498wD+LKlNSl25MjdZY4dU= +github.com/ugorji/go/codec v1.2.11/go.mod h1:UNopzCgEMSXjBc6AOMqYvWC1ktqTAfzJZUZgYf6w6lg= github.com/ulule/limiter/v3 v3.11.2 h1:P4yOrxoEMJbOTfRJR2OzjL90oflzYPPmWg+dvwN2tHA= github.com/ulule/limiter/v3 v3.11.2/go.mod h1:QG5GnFOCV+k7lrL5Y8kgEeeflPH3+Cviqlqa8SVSQxI= github.com/uptrace/bun v1.1.13 h1:IrxlIJHzCHFwmIzx66A9vi6qx8rHsHFiiT9LqlafHZw= @@ -671,8 +671,9 @@ go.uber.org/goleak v1.2.1 h1:NBol2c7O1ZokfZ0LEU9K6Whx/KnwvepVetCUhtKja4A= go.uber.org/multierr v1.1.0/go.mod h1:wR5kodmAFQ0UK8QlbwjlSNy0Z68gJhDJUG5sjR94q/0= go.uber.org/zap v1.9.1/go.mod h1:vwi/ZaCAaUcBkycHslxD9B2zi4UTXhF60s6SWpuDF0Q= go.uber.org/zap v1.10.0/go.mod h1:vwi/ZaCAaUcBkycHslxD9B2zi4UTXhF60s6SWpuDF0Q= -golang.org/x/arch v0.0.0-20210923205945-b76863e36670 h1:18EFjUmQOcUvxNYSkA6jO9VAiXCnxFY6NyDX0bHDmkU= golang.org/x/arch v0.0.0-20210923205945-b76863e36670/go.mod h1:5om86z9Hs0C8fWVUuoMHwpExlXzs5Tkyp9hOrfG7pp8= +golang.org/x/arch v0.3.0 h1:02VY4/ZcO/gBOH6PUaoiptASxtXU10jazRCP865E97k= +golang.org/x/arch v0.3.0/go.mod h1:5om86z9Hs0C8fWVUuoMHwpExlXzs5Tkyp9hOrfG7pp8= golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= golang.org/x/crypto v0.0.0-20190411191339-88737f569e3a/go.mod h1:WFFai1msRO1wXaEeE5yQxYXgSfI8pQAWXbQop6sCtWE= golang.org/x/crypto v0.0.0-20190510104115-cbcb75029529/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= diff --git a/vendor/github.com/bytedance/sonic/INTRODUCTION.md b/vendor/github.com/bytedance/sonic/INTRODUCTION.md deleted file mode 100644 index 6b42118a7..000000000 --- a/vendor/github.com/bytedance/sonic/INTRODUCTION.md +++ /dev/null @@ -1,48 +0,0 @@ -# Introduction to Sonic -## Background -According to the overall profiling of production services in Bytedance, we found that the overhead of JSON serialization and deserialization is unexpectedly high: the total is near to 10% CPU, and the extreme one accounts for more than 40% CPU. Therefore, **the performance of JSON lib is a key issue for the promotion of machine utilization**. - -## Research -We conducted a series of surveys and benchmarks on open-sourced JSON libraries for Golang, but the result is disappointing: **no silver bullet**. First of all, no one can perform at least the top three across various business scenarios. Even the most widely used [json-iterator](https://github.com/json-iterator/go) will severely degrade in generic (no-schema) or big-volume JSON serialization and deserialization. Secondly, compared with other JSON libraries writing in other languages, their speed is generally much slower. For example, [Simdjson-go](https://github.com/minio/simdjson-go) has a 50% reduction in decoding performance compared to [simdjson](https://github.com/simdjson/simdjson). What's more, we barely found JSON libraries which provide API to modify the underlying values. - -Therefore, we decided to **develop a brand-new JSON library with high performance as well as wide applicability**. - -## Thinking -Before starting our design, we need to figure out some questions: - -### Why is Json-iterator faster than Standard Library? -First of all, the **schema-based processing mechanism** used by the standard library is commendable, in which the parser can obtain meta information in advance when scanning, thereby shortening the time of branch selection. However, its original implementation did not make good use of this mechanism, instead, **it spent a lot of time reflecting to obtain meta info of schema**. Meanwhile, The approach of json-iterator is: Interprete structure as field-by-field encoding and decoding functions, and then assembled and cached them, minimizing the performance loss cost by reflection. But does it work once and for all? No. In practical tests, we found that **the deeper and larger the input JSON got, the smaller the gap between json-iterator and other libraries gradually became** - eventually event got surpassed: - - -The reason is that **this implementation transforms into a large number of interface encapsulations and function calls**, followed by function-call losses: -1. **Calling interface involves dynamic addressing of itab** -2. **Assembly functions cannot be inlined**, while Golang's function-call performance is poor (no parameter-passing-by-register) - -#### Is there a way to avoid the function-call overhead of dynamic assembly? -The first thing we thought about was code generation like [easyjson](https://github.com/mailru/easyjson). But it comes with **schema dependency and convenience losses**. To achieve a real drop-in replacement of the standard library, we turned to another technology - **[JIT](https://en.wikipedia.org/wiki/Jit) (just-in-time compiling)**. Because the compiled codec function is an integrated function, which can greatly reduce function calls while ensuring flexibility. - -### Why is Simdjson-go not fast enough? -[SIMD](https://en.wikipedia.org/wiki/SIMD) (Single-Instruction-Multi-Data) is a special set of CPU instructions for the parallel processing of vectorized data. At present, it is supported by most CPUs and widely used in image processing and big data computing. Undoubtedly, SIMD is useful in JSON processing (itoa, char-search， and so on are all suitable scenarios). We can see that simdjson-go is very competitive in large JSON scenarios (>100KB). However, for some extremely small or irregular character strings, **the extra load operation required by SIMD will lead to performance degradation**. Therefore, we need to dedicate ourselves to branch predicting and decide which scenarios should use SIMD and which should not (for example, the string length is less than 16 bytes). - -The second problem comes from the Go compiler itself. In order to ensure the compilation speed, **Golang does very little optimization work during the compilation phase** and cannot directly use compiler backends such as [LLVM](https://en.wikipedia.org/wiki/LLVM) (Low-Level Virtual Machine) for optimization. - -So, **can some crucial calculation functions be written in another language with higher execution efficiency**? -C/Clang is an ideal compilation tool (internal integration LLVM). But the key is how to embed the optimized assembly into Golang. - -### How to use Gjson well? -We also found that [gjson](https://github.com/tidwall/gjson) has a huge advantage in single-key lookup scenarios. This is because its lookup is implemented by a **lazy-load mechanism**, which subtlely skips passing-by values and effectively reduces a lot of unnecessary parsing. Practical application has proved that making good use of this feature in product can indeed bring benefits. But when it comes to multi-key lookup, Gjson does worse event than std, which is a side effect of its skipping mechanism - **searching for the same path leads to repeated parsing** (skip is also a lightweight parsing). Therefore, the accurate adaptation of practical scenarios is the key. - -## Design -Based on the above questions, our design is easy to implement: - -1. Aiming at the function-call overhead cost by the codec dynamic-assembly, **`JIT` tech is used to assemble opcodes (asm) corresponding to the schema at runtime**, which is finally cached into the off-heap memory in the form of Golang functions. -2. For practical scenarios where big data and small data coexist, we **use pre-conditional judgment** (string size, floating precision, etc.) **to combine `SIMD` with scalar instructions** to achieve the best adaptation. -3. As for insufficiency in compiling optimization of go language, we decided to **use `C/Clang` to write and compile core computational functions**, and **developed a set of [asm2asm](https://github.com/chenzhuoyu/asm2asm) tools to translate the fully optimized x86 assembly into plan9** and finally load it into Golang runtime. -4. Giving the big speed gap between parsing and skipping, the **`lazy-load` mechanism** is certainly used in our AST parser, but in **a more adaptive and efficient way to reduce the overhead of multiple-key queries**. - - -In detail, we conducted some further optimization: -1. Since the native-asm functions cannot be inlined in Golang, we found that its cost even exceeded the improvement brought by the optimization of the C compiler. So we reimplemented a set of lightweight function-calls in JIT: - - `Global-function-table + static offset` for calling instruction - - **Pass parameters using registers** -2. `Sync.Map` was used to cache the codecs at first, but for our **quasi-static** (read far more than write), **fewer elements** (usually no more than a few dozen) scenarios, its performance is not optimal, so we reimplement a high-performance and concurrent-safe cache with `open-addressing-hash + RCU` tech.
\ No newline at end of file diff --git a/vendor/github.com/bytedance/sonic/README.md b/vendor/github.com/bytedance/sonic/README.md index 9cc42c462..cdb32a57d 100644 --- a/vendor/github.com/bytedance/sonic/README.md +++ b/vendor/github.com/bytedance/sonic/README.md @@ -1,5 +1,7 @@ # Sonic +English | [中文](README_ZH_CN.md) + A blazingly fast JSON serializing & deserializing library, accelerated by JIT (just-in-time compiling) and SIMD (single-instruction-multiple-data). ## Requirement @@ -76,14 +78,14 @@ BenchmarkSetOne_Parallel_Sjson-16 18194 ns/op 715.7 BenchmarkSetOne_Parallel_Jsoniter-16 33560 ns/op 388.05 MB/s 45892 B/op 964 allocs/op ``` - [Small](https://github.com/bytedance/sonic/blob/main/testdata/small.go) (400B, 11 keys, 3 layers) - + - [Large](https://github.com/bytedance/sonic/blob/main/testdata/twitter.json) (635KB, 10000+ key, 6 layers) - + See [bench.sh](https://github.com/bytedance/sonic/blob/main/bench.sh) for benchmark codes. ## How it works -See [INTRODUCTION.md](INTRODUCTION.md). +See [INTRODUCTION.md](./docs/INTRODUCTION.md). ## Usage @@ -104,28 +106,29 @@ err := sonic.Unmarshal(output, &data) Sonic supports decoding json from `io.Reader` or encoding objects into `io.`Writer`, aims at handling multiple values as well as reducing memory consumption. - encoder ```go -import "github.com/bytedance/sonic/encoder" - var o1 = map[string]interface{}{ "a": "b", } var o2 = 1 var w = bytes.NewBuffer(nil) -var enc = encoder.NewStreamEncoder(w) +var enc = sonic.ConfigDefault.NewEncoder(w) enc.Encode(o1) enc.Encode(o2) -println(w.String()) // "{"a":"b"}\n1" +fmt.Println(w.String()) +// Output: +// {"a":"b"} +// 1 ``` - decoder ```go -import "github.com/bytedance/sonic/decoder" - var o = map[string]interface{}{} var r = strings.NewReader(`{"a":"b"}{"1":"2"}`) -var dec = decoder.NewStreamDecoder(r) +var dec = sonic.ConfigDefault.NewDecoder(r) dec.Decode(&o) dec.Decode(&o) -fmt.Printf("%+v", o) // map[1:2 a:b] +fmt.Printf("%+v", o) +// Output: +// map[1:2 a:b] ``` ### Use Number/Use Int64 diff --git a/vendor/github.com/bytedance/sonic/README_ZH_CN.md b/vendor/github.com/bytedance/sonic/README_ZH_CN.md new file mode 100644 index 000000000..43fd1d677 --- /dev/null +++ b/vendor/github.com/bytedance/sonic/README_ZH_CN.md @@ -0,0 +1,382 @@ +# Sonic + +[English](README.md) | 中文 + +一个速度奇快的 JSON 序列化/反序列化库，由 JIT （即时编译）和 SIMD （单指令流多数据流）加速。 + +## 依赖 + +- Go 1.15~1.20 +- Linux/MacOS/Windows +- Amd64 架构 + +## 特色 + +- 运行时对象绑定，无需代码生成 +- 完备的 JSON 操作 API +- 快，更快，还要更快！ + +## 基准测试 + +对于**所有大小**的 json 和**所有使用场景**， **Sonic 表现均为最佳**。 +- [中型](https://github.com/bytedance/sonic/blob/main/decoder/testdata_test.go#L19) (13kB, 300+ 键, 6 层) +```powershell +goversion: 1.17.1 +goos: darwin +goarch: amd64 +cpu: Intel(R) Core(TM) i9-9880H CPU @ 2.30GHz +BenchmarkEncoder_Generic_Sonic-16 32393 ns/op 402.40 MB/s 11965 B/op 4 allocs/op +BenchmarkEncoder_Generic_Sonic_Fast-16 21668 ns/op 601.57 MB/s 10940 B/op 4 allocs/op +BenchmarkEncoder_Generic_JsonIter-16 42168 ns/op 309.12 MB/s 14345 B/op 115 allocs/op +BenchmarkEncoder_Generic_GoJson-16 65189 ns/op 199.96 MB/s 23261 B/op 16 allocs/op +BenchmarkEncoder_Generic_StdLib-16 106322 ns/op 122.60 MB/s 49136 B/op 789 allocs/op +BenchmarkEncoder_Binding_Sonic-16 6269 ns/op 2079.26 MB/s 14173 B/op 4 allocs/op +BenchmarkEncoder_Binding_Sonic_Fast-16 5281 ns/op 2468.16 MB/s 12322 B/op 4 allocs/op +BenchmarkEncoder_Binding_JsonIter-16 20056 ns/op 649.93 MB/s 9488 B/op 2 allocs/op +BenchmarkEncoder_Binding_GoJson-16 8311 ns/op 1568.32 MB/s 9481 B/op 1 allocs/op +BenchmarkEncoder_Binding_StdLib-16 16448 ns/op 792.52 MB/s 9479 B/op 1 allocs/op +BenchmarkEncoder_Parallel_Generic_Sonic-16 6681 ns/op 1950.93 MB/s 12738 B/op 4 allocs/op +BenchmarkEncoder_Parallel_Generic_Sonic_Fast-16 4179 ns/op 3118.99 MB/s 10757 B/op 4 allocs/op +BenchmarkEncoder_Parallel_Generic_JsonIter-16 9861 ns/op 1321.84 MB/s 14362 B/op 115 allocs/op +BenchmarkEncoder_Parallel_Generic_GoJson-16 18850 ns/op 691.52 MB/s 23278 B/op 16 allocs/op +BenchmarkEncoder_Parallel_Generic_StdLib-16 45902 ns/op 283.97 MB/s 49174 B/op 789 allocs/op +BenchmarkEncoder_Parallel_Binding_Sonic-16 1480 ns/op 8810.09 MB/s 13049 B/op 4 allocs/op +BenchmarkEncoder_Parallel_Binding_Sonic_Fast-16 1209 ns/op 10785.23 MB/s 11546 B/op 4 allocs/op +BenchmarkEncoder_Parallel_Binding_JsonIter-16 6170 ns/op 2112.58 MB/s 9504 B/op 2 allocs/op +BenchmarkEncoder_Parallel_Binding_GoJson-16 3321 ns/op 3925.52 MB/s 9496 B/op 1 allocs/op +BenchmarkEncoder_Parallel_Binding_StdLib-16 3739 ns/op 3486.49 MB/s 9480 B/op 1 allocs/op + +BenchmarkDecoder_Generic_Sonic-16 66812 ns/op 195.10 MB/s 57602 B/op 723 allocs/op +BenchmarkDecoder_Generic_Sonic_Fast-16 54523 ns/op 239.07 MB/s 49786 B/op 313 allocs/op +BenchmarkDecoder_Generic_StdLib-16 124260 ns/op 104.90 MB/s 50869 B/op 772 allocs/op +BenchmarkDecoder_Generic_JsonIter-16 91274 ns/op 142.81 MB/s 55782 B/op 1068 allocs/op +BenchmarkDecoder_Generic_GoJson-16 88569 ns/op 147.17 MB/s 66367 B/op 973 allocs/op +BenchmarkDecoder_Binding_Sonic-16 32557 ns/op 400.38 MB/s 28302 B/op 137 allocs/op +BenchmarkDecoder_Binding_Sonic_Fast-16 28649 ns/op 455.00 MB/s 24999 B/op 34 allocs/op +BenchmarkDecoder_Binding_StdLib-16 111437 ns/op 116.97 MB/s 10576 B/op 208 allocs/op +BenchmarkDecoder_Binding_JsonIter-16 35090 ns/op 371.48 MB/s 14673 B/op 385 allocs/op +BenchmarkDecoder_Binding_GoJson-16 28738 ns/op 453.59 MB/s 22039 B/op 49 allocs/op +BenchmarkDecoder_Parallel_Generic_Sonic-16 12321 ns/op 1057.91 MB/s 57233 B/op 723 allocs/op +BenchmarkDecoder_Parallel_Generic_Sonic_Fast-16 10644 ns/op 1224.64 MB/s 49362 B/op 313 allocs/op +BenchmarkDecoder_Parallel_Generic_StdLib-16 57587 ns/op 226.35 MB/s 50874 B/op 772 allocs/op +BenchmarkDecoder_Parallel_Generic_JsonIter-16 38666 ns/op 337.12 MB/s 55789 B/op 1068 allocs/op +BenchmarkDecoder_Parallel_Generic_GoJson-16 30259 ns/op 430.79 MB/s 66370 B/op 974 allocs/op +BenchmarkDecoder_Parallel_Binding_Sonic-16 5965 ns/op 2185.28 MB/s 27747 B/op 137 allocs/op +BenchmarkDecoder_Parallel_Binding_Sonic_Fast-16 5170 ns/op 2521.31 MB/s 24715 B/op 34 allocs/op +BenchmarkDecoder_Parallel_Binding_StdLib-16 27582 ns/op 472.58 MB/s 10576 B/op 208 allocs/op +BenchmarkDecoder_Parallel_Binding_JsonIter-16 13571 ns/op 960.51 MB/s 14685 B/op 385 allocs/op +BenchmarkDecoder_Parallel_Binding_GoJson-16 10031 ns/op 1299.51 MB/s 22111 B/op 49 allocs/op + +BenchmarkGetOne_Sonic-16 3276 ns/op 3975.78 MB/s 24 B/op 1 allocs/op +BenchmarkGetOne_Gjson-16 9431 ns/op 1380.81 MB/s 0 B/op 0 allocs/op +BenchmarkGetOne_Jsoniter-16 51178 ns/op 254.46 MB/s 27936 B/op 647 allocs/op +BenchmarkGetOne_Parallel_Sonic-16 216.7 ns/op 60098.95 MB/s 24 B/op 1 allocs/op +BenchmarkGetOne_Parallel_Gjson-16 1076 ns/op 12098.62 MB/s 0 B/op 0 allocs/op +BenchmarkGetOne_Parallel_Jsoniter-16 17741 ns/op 734.06 MB/s 27945 B/op 647 allocs/op +BenchmarkSetOne_Sonic-16 9571 ns/op 1360.61 MB/s 1584 B/op 17 allocs/op +BenchmarkSetOne_Sjson-16 36456 ns/op 357.22 MB/s 52180 B/op 9 allocs/op +BenchmarkSetOne_Jsoniter-16 79475 ns/op 163.86 MB/s 45862 B/op 964 allocs/op +BenchmarkSetOne_Parallel_Sonic-16 850.9 ns/op 15305.31 MB/s 1584 B/op 17 allocs/op +BenchmarkSetOne_Parallel_Sjson-16 18194 ns/op 715.77 MB/s 52247 B/op 9 allocs/op +BenchmarkSetOne_Parallel_Jsoniter-16 33560 ns/op 388.05 MB/s 45892 B/op 964 allocs/op +``` +- [小型](https://github.com/bytedance/sonic/blob/main/testdata/small.go) (400B, 11 个键, 3 层) + +- [大型](https://github.com/bytedance/sonic/blob/main/testdata/twitter.json) (635kB, 10000+ 个键, 6 层) + + +要查看基准测试代码，请参阅 [bench.sh](https://github.com/bytedance/sonic/blob/main/bench.sh) 。 + +## 工作原理 + +请参阅 [INTRODUCTION_ZH_CN.md](./docs/INTRODUCTION_ZH_CN.md). + +## 使用方式 + +### 序列化/反序列化 + +默认的行为基本上与 `encoding/json` 相一致，除了 HTML 转义形式（参见 [Escape HTML](https://github.com/bytedance/sonic/blob/main/README.md#escape-html)) 和 `SortKeys` 功能（参见 [Sort Keys](https://github.com/bytedance/sonic/blob/main/README.md#sort-keys)）**没有**遵循 [RFC8259](https://datatracker.ietf.org/doc/html/rfc8259) 。 + ```go +import "github.com/bytedance/sonic" + +var data YourSchema +// Marshal +output, err := sonic.Marshal(&data) +// Unmarshal +err := sonic.Unmarshal(output, &data) + ``` + +### 流式输入输出 + +Sonic 支持解码 `io.Reader` 中输入的 json，或将对象编码为 json 后输出至 `io.Writer`，以处理多个值并减少内存消耗。 +- 编码器 +```go +var o1 = map[string]interface{}{ + "a": "b", +} +var o2 = 1 +var w = bytes.NewBuffer(nil) +var enc = sonic.ConfigDefault.NewEncoder(w) +enc.Encode(o1) +enc.Encode(o2) +fmt.Println(w.String()) +// Output: +// {"a":"b"} +// 1 +``` +- 解码器 +```go +var o = map[string]interface{}{} +var r = strings.NewReader(`{"a":"b"}{"1":"2"}`) +var dec = sonic.ConfigDefault.NewDecoder(r) +dec.Decode(&o) +dec.Decode(&o) +fmt.Printf("%+v", o) +// Output: +// map[1:2 a:b] +``` + +### 使用 `Number` / `int64` + +```go +import "github.com/bytedance/sonic/decoder" + +var input = `1` +var data interface{} + +// default float64 +dc := decoder.NewDecoder(input) +dc.Decode(&data) // data == float64(1) +// use json.Number +dc = decoder.NewDecoder(input) +dc.UseNumber() +dc.Decode(&data) // data == json.Number("1") +// use int64 +dc = decoder.NewDecoder(input) +dc.UseInt64() +dc.Decode(&data) // data == int64(1) + +root, err := sonic.GetFromString(input) +// Get json.Number +jn := root.Number() +jm := root.InterfaceUseNumber().(json.Number) // jn == jm +// Get float64 +fn := root.Float64() +fm := root.Interface().(float64) // jn == jm + ``` + +### 对键排序 + +考虑到排序带来的性能损失（约 10% ）， sonic 默认不会启用这个功能。如果你的组件依赖这个行为（如 [zstd](https://github.com/facebook/zstd)) ，可以仿照下面的例子： +```go +import "github.com/bytedance/sonic" +import "github.com/bytedance/sonic/encoder" + +// Binding map only +m := map[string]interface{}{} +v, err := encoder.Encode(m, encoder.SortMapKeys) + +// Or ast.Node.SortKeys() before marshal +var root := sonic.Get(JSON) +err := root.SortKeys() +``` + +### HTML 转义 + +考虑到性能损失（约15%）， sonic 默认不会启用这个功能。你可以使用 `encoder.EscapeHTML` 选项来开启（与 `encoding/json.HTMLEscape` 行为一致）。 +```go +import "github.com/bytedance/sonic" + +v := map[string]string{"&&":"<>"} +ret, err := Encode(v, EscapeHTML) // ret == `{"\u0026\u0026":{"X":"\u003c\u003e"}}` +``` + +### 紧凑格式 +Sonic 默认将基本类型（ `struct` ， `map` 等）编码为紧凑格式的 JSON ，除非使用 `json.RawMessage` or `json.Marshaler` 进行编码： sonic 确保输出的 JSON 合法，但出于性能考虑，**不会**加工成紧凑格式。我们提供选项 `encoder.CompactMarshaler` 来添加此过程， + +### 打印错误 + +如果输入的 JSON 存在无效的语法，sonic 将返回 `decoder.SyntaxError`，该错误支持错误位置的美化输出。 +```go +import "github.com/bytedance/sonic" +import "github.com/bytedance/sonic/decoder" + +var data interface{} +err := sonic.UnmarshalString("[[[}]]", &data) +if err != nil { + /* One line by default */ + println(e.Error()) // "Syntax error at index 3: invalid char\n\n\t[[[}]]\n\t...^..\n" + /* Pretty print */ + if e, ok := err.(decoder.SyntaxError); ok { + /*Syntax error at index 3: invalid char + + [[[}]] + ...^.. + */ + print(e.Description()) + } else if me, ok := err.(*decoder.MismatchTypeError); ok { + // decoder.MismatchTypeError is new to Sonic v1.6.0 + print(me.Description()) + } +} +``` + +#### 类型不匹配 [Sonic v1.6.0] + +如果给定键中存在**类型不匹配**的值， sonic 会抛出 `decoder.MismatchTypeError` （如果有多个，只会报告最后一个），但仍会跳过错误的值并解码下一个 JSON 。 +```go +import "github.com/bytedance/sonic" +import "github.com/bytedance/sonic/decoder" + +var data = struct{ + A int + B int +}{} +err := UnmarshalString(`{"A":"1","B":1}`, &data) +println(err.Error()) // Mismatch type int with value string "at index 5: mismatched type with value\n\n\t{\"A\":\"1\",\"B\":1}\n\t.....^.........\n" +fmt.Printf("%+v", data) // {A:0 B:1} +``` +### `Ast.Node` + +Sonic/ast.Node 是完全独立的 JSON 抽象语法树库。它实现了序列化和反序列化，并提供了获取和修改通用数据的鲁棒的 API。 + +#### 查找/索引 + +通过给定的路径搜索 JSON 片段，路径必须为非负整数，字符串或 `nil` 。 +```go +import "github.com/bytedance/sonic" + +input := []byte(`{"key1":[{},{"key2":{"key3":[1,2,3]}}]}`) + +// no path, returns entire json +root, err := sonic.Get(input) +raw := root.Raw() // == string(input) + +// multiple paths +root, err := sonic.Get(input, "key1", 1, "key2") +sub := root.Get("key3").Index(2).Int64() // == 3 +``` +**注意**：由于 `Index()` 使用偏移量来定位数据，比使用扫描的 `Get()` 要快的多，建议尽可能的使用 `Index` 。 Sonic 也提供了另一个 API， `IndexOrGet()` ，以偏移量为基础并且也确保键的匹配。 + +#### 修改 + +使用 ` Set()` / `Unset()` 修改 json 的内容 +```go +import "github.com/bytedance/sonic" + +// Set +exist, err := root.Set("key4", NewBool(true)) // exist == false +alias1 := root.Get("key4") +println(alias1.Valid()) // true +alias2 := root.Index(1) +println(alias1 == alias2) // true + +// Unset +exist, err := root.UnsetByIndex(1) // exist == true +println(root.Get("key4").Check()) // "value not exist" +``` + +#### 序列化 +要将 `ast.Node` 编码为 json ，使用 `MarshalJson()` 或者 `json.Marshal()` （必须传递指向节点的指针） +```go +import ( + "encoding/json" + "github.com/bytedance/sonic" +) + +buf, err := root.MarshalJson() +println(string(buf)) // {"key1":[{},{"key2":{"key3":[1,2,3]}}]} +exp, err := json.Marshal(&root) // WARN: use pointer +println(string(buf) == string(exp)) // true +``` + +#### APIs +- 合法性检查： `Check()`, `Error()`, `Valid()`, `Exist()` +- 索引： `Index()`, `Get()`, `IndexPair()`, `IndexOrGet()`, `GetByPath()` +- 转换至 go 内置类型： `Int64()`, `Float64()`, `String()`, `Number()`, `Bool()`, `Map[UseNumber|UseNode]()`, `Array[UseNumber|UseNode]()`, `Interface[UseNumber|UseNode]()` +- go 类型打包： `NewRaw()`, `NewNumber()`, `NewNull()`, `NewBool()`, `NewString()`, `NewObject()`, `NewArray()` +- 迭代： `Values()`, `Properties()`, `ForEach()`, `SortKeys()` +- 修改： `Set()`, `SetByIndex()`, `Add()` + +## 兼容性 +由于开发高性能代码的困难性， Sonic **不**保证对所有环境的支持。对于在不同环境中使用 Sonic 构建应用程序的开发者，我们有以下建议： + +- 在 **Mac M1** 上开发：确保在您的计算机上安装了 Rosetta 2，并在构建时设置 `GOARCH=amd64` 。 Rosetta 2 可以自动将 x86 二进制文件转换为 arm64 二进制文件，并在 Mac M1 上运行 x86 应用程序。 +- 在 **Linux arm64** 上开发：您可以安装 qemu 并使用 `qemu-x86_64 -cpu max` 命令来将 x86 二进制文件转换为 arm64 二进制文件。qemu可以实现与Mac M1上的Rosetta 2类似的转换效果。 + +对于希望在不使用 qemu 下使用 sonic 的开发者，或者希望处理 JSON 时与 `encoding/JSON` 严格保持一致的开发者，我们在 `sonic.API` 中提供了一些兼容性 API +- `ConfigDefault`: 在支持 sonic 的环境下 sonic 的默认配置（`EscapeHTML=false`，`SortKeys=false`等）。行为与具有相应配置的 `encoding/json` 一致，一些选项，如 `SortKeys=false` 将无效。 +- `ConfigStd`: 在支持 sonic 的环境下与标准库兼容的配置（`EscapeHTML=true`，`SortKeys=true`等）。行为与 `encoding/json` 一致。 +- `ConfigFastest`: 在支持 sonic 的环境下运行最快的配置（`NoQuoteTextMarshaler=true`）。行为与具有相应配置的 `encoding/json` 一致，某些选项将无效。 + +## 注意事项 + +### 预热 +由于 Sonic 使用 [golang-asm](https://github.com/twitchyliquid64/golang-asm) 作为 JIT 汇编器，这个库并不适用于运行时编译，第一次运行一个大型模式可能会导致请求超时甚至进程内存溢出。为了更好地稳定性，我们建议在运行大型模式或在内存有限的应用中，在使用 `Marshal()/Unmarshal()` 前运行 `Pretouch()`。 +```go +import ( + "reflect" + "github.com/bytedance/sonic" + "github.com/bytedance/sonic/option" +) + +func init() { + var v HugeStruct + + // For most large types (nesting depth <= option.DefaultMaxInlineDepth) + err := sonic.Pretouch(reflect.TypeOf(v)) + + // with more CompileOption... + err := sonic.Pretouch(reflect.TypeOf(v), + // If the type is too deep nesting (nesting depth > option.DefaultMaxInlineDepth), + // you can set compile recursive loops in Pretouch for better stability in JIT. + option.WithCompileRecursiveDepth(loop), + // For a large nested struct, try to set a smaller depth to reduce compiling time. + option.WithCompileMaxInlineDepth(depth), + ) +} +``` + +### 拷贝字符串 + +当解码 **没有转义字符的字符串**时， sonic 会从原始的 JSON 缓冲区内引用而不是复制到新的一个缓冲区中。这对 CPU 的性能方面很有帮助，但是可能因此在解码后对象仍在使用的时候将整个 JSON 缓冲区保留在内存中。实践中我们发现，通过引用 JSON 缓冲区引入的额外内存通常是解码后对象的 20% 至 80% ，一旦应用长期保留这些对象（如缓存以备重用），服务器所使用的内存可能会增加。我们提供了选项 `decoder.CopyString()` 供用户选择，不引用 JSON 缓冲区。这可能在一定程度上降低 CPU 性能。 + +### 传递字符串还是字节数组？ +为了和 `encoding/json` 保持一致，我们提供了传递 `[]byte` 作为参数的 API ，但考虑到安全性，字符串到字节的复制是同时进行的，这在原始 JSON 非常大时可能会导致性能损失。因此，你可以使用 `UnmarshalString()` 和 `GetFromString()` 来传递字符串，只要你的原始数据是字符串，或**零拷贝类型转换**对于你的字节数组是安全的。我们也提供了 `MarshalString()` 的 API ，以便对编码的 JSON 字节数组进行**零拷贝类型转换**，因为 sonic 输出的字节始终是重复并且唯一的，所以这样是安全的。 + +### 加速 `encoding.TextMarshaler` + +为了保证数据安全性， `sonic.Encoder` 默认会对来自 `encoding.TextMarshaler` 接口的字符串进行引用和转义，如果大部分数据都是这种形式那可能会导致很大的性能损失。我们提供了 `encoder.NoQuoteTextMarshaler` 选项来跳过这些操作，但你**必须**保证他们的输出字符串依照 [RFC8259](https://datatracker.ietf.org/doc/html/rfc8259) 进行了转义和引用。 + + +### 泛型的性能优化 + +在 **完全解析**的场景下， `Unmarshal()` 表现得比 `Get()`+`Node.Interface()` 更好。但是如果你只有特定 JSON 的部分模式，你可以将 `Get()` 和 `Unmarshal()` 结合使用： +```go +import "github.com/bytedance/sonic" + +node, err := sonic.GetFromString(_TwitterJson, "statuses", 3, "user") +var user User // your partial schema... +err = sonic.UnmarshalString(node.Raw(), &user) +``` +甚至如果你没有任何模式，可以用 `ast.Node` 代替 `map` 或 `interface` 作为泛型的容器： +```go +import "github.com/bytedance/sonic" + +root, err := sonic.GetFromString(_TwitterJson) +user := root.GetByPath("statuses", 3, "user") // === root.Get("status").Index(3).Get("user") +err = user.Check() + +// err = user.LoadAll() // only call this when you want to use 'user' concurrently... +go someFunc(user) +``` +为什么？因为 `ast.Node` 使用 `array` 来存储其子节点： +- 在插入（反序列化）和扫描（序列化）数据时，`Array` 的性能比 `Map` **好得多**； +- **哈希**（`map[x]`）的效率不如**索引**（`array[x]`）高效，而 `ast.Node` 可以在数组和对象上使用索引； +- 使用 `Interface()` / `Map()` 意味着 sonic 必须解析所有的底层值，而 `ast.Node` 可以**按需解析**它们。 + +**注意**：由于 `ast.Node` 的惰性加载设计，其**不能**直接保证并发安全性，但你可以调用 `Node.Load()` / `Node.LoadAll()` 来实现并发安全。尽管可能会带来性能损失，但仍比转换成 `map` 或 `interface{}` 更为高效。 + +## 社区 + +Sonic 是 [CloudWeGo](https://www.cloudwego.io/) 下的一个子项目。我们致力于构建云原生生态系统。 diff --git a/vendor/github.com/bytedance/sonic/api.go b/vendor/github.com/bytedance/sonic/api.go index a2bc67eaa..a042476f1 100644 --- a/vendor/github.com/bytedance/sonic/api.go +++ b/vendor/github.com/bytedance/sonic/api.go @@ -169,9 +169,10 @@ func UnmarshalString(buf string, val interface{}) error { // and returns its representing ast.Node. // // Each path arg must be integer or string: -// - Integer means searching current node as array -// - String means searching current node as object +// - Integer is target index(>=0), means searching current node as array. +// - String is target key, means searching current node as object. // +// // Note, the api expects the json is well-formed at least, // otherwise it may return unexpected result. func Get(src []byte, path ...interface{}) (ast.Node, error) { diff --git a/vendor/github.com/bytedance/sonic/ast/api_amd64.go b/vendor/github.com/bytedance/sonic/ast/api_amd64.go index 6b3458aee..3047f59c3 100644 --- a/vendor/github.com/bytedance/sonic/ast/api_amd64.go +++ b/vendor/github.com/bytedance/sonic/ast/api_amd64.go @@ -1,5 +1,20 @@ // +build amd64,go1.15,!go1.21 +/* + * 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 @@ -17,10 +32,12 @@ import ( var typeByte = rt.UnpackEface(byte(0)).Type +//go:nocheckptr func quote(buf *[]byte, val string) { *buf = append(*buf, '"') if len(val) == 0 { *buf = append(*buf, '"') + return } sp := rt.IndexChar(val, 0) @@ -99,7 +116,9 @@ func (self *Parser) skipFast() (int, types.ParsingError) { } func (self *Parser) getByPath(path ...interface{}) (int, types.ParsingError) { - start := native.GetByPath(&self.s, &self.p, &path) + fsm := types.NewStateMachine() + start := native.GetByPath(&self.s, &self.p, &path, fsm) + types.FreeStateMachine(fsm) runtime.KeepAlive(path) if start < 0 { return self.p, types.ParsingError(-start) @@ -107,7 +126,6 @@ func (self *Parser) getByPath(path ...interface{}) (int, types.ParsingError) { return start, 0 } - func (self *Searcher) GetByPath(path ...interface{}) (Node, error) { var err types.ParsingError var start int @@ -115,6 +133,13 @@ func (self *Searcher) GetByPath(path ...interface{}) (Node, error) { self.parser.p = 0 start, err = self.parser.getByPath(path...) if err != 0 { + // for compatibility with old version + if err == types.ERR_NOT_FOUND { + return Node{}, ErrNotExist + } + if err == types.ERR_UNSUPPORT_TYPE { + panic("path must be either int(>=0) or string") + } return Node{}, self.parser.syntaxError(err) } diff --git a/vendor/github.com/bytedance/sonic/ast/api_compat.go b/vendor/github.com/bytedance/sonic/ast/api_compat.go index 642330c51..b18b5ae8c 100644 --- a/vendor/github.com/bytedance/sonic/ast/api_compat.go +++ b/vendor/github.com/bytedance/sonic/ast/api_compat.go @@ -1,5 +1,21 @@ // +build !amd64 go1.21 +/* + * 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 ( @@ -24,8 +40,6 @@ func unquote(src string) (string, types.ParsingError) { return rt.Mem2Str(out), 0 } - - func decodeBase64(src string) ([]byte, error) { return base64.StdEncoding.DecodeString(src) } @@ -53,7 +67,12 @@ func (self *Parser) skip() (int, types.ParsingError) { } func (self *Parser) skipFast() (int, types.ParsingError) { - return self.skip() + 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 { @@ -70,17 +89,16 @@ func (self *Searcher) GetByPath(path ...interface{}) (Node, error) { var err types.ParsingError for _, p := range path { - switch p := p.(type) { - case int: - if err = self.parser.searchIndex(p); err != 0 { + if idx, ok := p.(int); ok && idx >= 0 { + if err = self.parser.searchIndex(idx); err != 0 { return Node{}, self.parser.ExportError(err) } - case string: - if err = self.parser.searchKey(p); err != 0 { + } else if key, ok := p.(string); ok { + if err = self.parser.searchKey(key); err != 0 { return Node{}, self.parser.ExportError(err) } - default: - panic("path must be either int or string") + } else { + panic("path must be either int(>=0) or string") } } diff --git a/vendor/github.com/bytedance/sonic/ast/decode.go b/vendor/github.com/bytedance/sonic/ast/decode.go index d54e98318..6a5f6fea3 100644 --- a/vendor/github.com/bytedance/sonic/ast/decode.go +++ b/vendor/github.com/bytedance/sonic/ast/decode.go @@ -1,3 +1,19 @@ +/* + * 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 ( @@ -24,6 +40,7 @@ func isSpace(c byte) bool { return (int(1<<c) & _blankCharsMask) != 0 } +//go:nocheckptr func skipBlank(src string, pos int) int { se := uintptr(rt.IndexChar(src, len(src))) sp := uintptr(rt.IndexChar(src, pos)) @@ -77,6 +94,7 @@ func decodeFalse(src string, pos int) (ret int) { return -int(types.ERR_INVALID_CHAR) } +//go:nocheckptr func decodeString(src string, pos int) (ret int, v string) { ret, ep := skipString(src, pos) if ep == -1 { @@ -112,6 +130,7 @@ func isDigit(c byte) bool { return c >= '0' && c <= '9' } +//go:nocheckptr func decodeInt64(src string, pos int) (ret int, v int64, err error) { sp := uintptr(rt.IndexChar(src, pos)) ss := uintptr(sp) @@ -161,6 +180,7 @@ func isNumberChars(c byte) bool { return (c >= '0' && c <= '9') || c == '+' || c == '-' || c == 'e' || c == 'E' || c == '.' } +//go:nocheckptr func decodeFloat64(src string, pos int) (ret int, v float64, err error) { sp := uintptr(rt.IndexChar(src, pos)) ss := uintptr(sp) @@ -255,6 +275,7 @@ func decodeValue(src string, pos int) (ret int, v types.JsonState) { } } +//go:nocheckptr func skipNumber(src string, pos int) (ret int) { sp := uintptr(rt.IndexChar(src, pos)) se := uintptr(rt.IndexChar(src, len(src))) @@ -281,7 +302,7 @@ func skipNumber(src string, pos int) (ret int) { } else if nextNeedDigit { return -int(types.ERR_INVALID_CHAR) } else if c == '.' { - if !lastIsDigit || pointer || sp == ss { + if !lastIsDigit || pointer || exponent || sp == ss { return -int(types.ERR_INVALID_CHAR) } pointer = true @@ -319,6 +340,7 @@ func skipNumber(src string, pos int) (ret int) { return int(uintptr(sp) - uintptr((*rt.GoString)(unsafe.Pointer(&src)).Ptr)) } +//go:nocheckptr func skipString(src string, pos int) (ret int, ep int) { if pos+1 >= len(src) { return -int(types.ERR_EOF), -1 @@ -327,6 +349,7 @@ func skipString(src string, pos int) (ret int, ep int) { sp := uintptr(rt.IndexChar(src, pos)) se := uintptr(rt.IndexChar(src, len(src))) + // not start with quote if *(*byte)(unsafe.Pointer(sp)) != '"' { return -int(types.ERR_INVALID_CHAR), -1 } @@ -344,18 +367,16 @@ func skipString(src string, pos int) (ret int, ep int) { } sp += 1 if c == '"' { - break + return int(uintptr(sp) - uintptr((*rt.GoString)(unsafe.Pointer(&src)).Ptr)), ep } } - if sp > se { - return -int(types.ERR_EOF), -1 - } - runtime.KeepAlive(src) - return int(uintptr(sp) - uintptr((*rt.GoString)(unsafe.Pointer(&src)).Ptr)), ep + // not found the closed quote until EOF + return -int(types.ERR_EOF), -1 } +//go:nocheckptr func skipPair(src string, pos int, lchar byte, rchar byte) (ret int) { if pos+1 >= len(src) { return -int(types.ERR_EOF) @@ -403,7 +424,7 @@ func skipPair(src string, pos int, lchar byte, rchar byte) (ret int) { return int(uintptr(sp) - uintptr((*rt.GoString)(unsafe.Pointer(&src)).Ptr)) } -func skipValue(src string, pos int) (ret int, start int) { +func skipValueFast(src string, pos int) (ret int, start int) { pos = skipBlank(src, pos) if pos < 0 { return pos, -1 @@ -428,3 +449,127 @@ func skipValue(src string, pos int) (ret int, start int) { } return ret, pos } + +func skipValue(src string, pos int) (ret int, start int) { + pos = skipBlank(src, pos) + if pos < 0 { + return pos, -1 + } + switch c := src[pos]; c { + case 'n': + ret = decodeNull(src, pos) + case '"': + ret, _ = skipString(src, pos) + case '{': + ret, _ = skipObject(src, pos) + case '[': + ret, _ = skipArray(src, pos) + case 't': + ret = decodeTrue(src, pos) + case 'f': + ret = decodeFalse(src, pos) + case '-', '+', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9': + ret = skipNumber(src, pos) + default: + ret = -int(types.ERR_INVALID_CHAR) + } + return ret, pos +} + +func skipObject(src string, pos int) (ret int, start int) { + start = skipBlank(src, pos) + if start < 0 { + return start, -1 + } + + if src[start] != '{' { + return -int(types.ERR_INVALID_CHAR), -1 + } + + pos = start + 1 + pos = skipBlank(src, pos) + if pos < 0 { + return pos, -1 + } + if src[pos] == '}' { + return pos + 1, start + } + + for { + pos, _ = skipString(src, pos) + if pos < 0 { + return pos, -1 + } + + pos = skipBlank(src, pos) + if pos < 0 { + return pos, -1 + } + if src[pos] != ':' { + return -int(types.ERR_INVALID_CHAR), -1 + } + + pos++ + pos, _ = skipValue(src, pos) + if pos < 0 { + return pos, -1 + } + + pos = skipBlank(src, pos) + if pos < 0 { + return pos, -1 + } + if src[pos] == '}' { + return pos + 1, start + } + if src[pos] != ',' { + return -int(types.ERR_INVALID_CHAR), -1 + } + + pos++ + pos = skipBlank(src, pos) + if pos < 0 { + return pos, -1 + } + + } +} + +func skipArray(src string, pos int) (ret int, start int) { + start = skipBlank(src, pos) + if start < 0 { + return start, -1 + } + + if src[start] != '[' { + return -int(types.ERR_INVALID_CHAR), -1 + } + + pos = start + 1 + pos = skipBlank(src, pos) + if pos < 0 { + return pos, -1 + } + if src[pos] == ']' { + return pos + 1, start + } + + for { + pos, _ = skipValue(src, pos) + if pos < 0 { + return pos, -1 + } + + pos = skipBlank(src, pos) + if pos < 0 { + return pos, -1 + } + if src[pos] == ']' { + return pos + 1, start + } + if src[pos] != ',' { + return -int(types.ERR_INVALID_CHAR), -1 + } + pos++ + } +} diff --git a/vendor/github.com/bytedance/sonic/ast/node.go b/vendor/github.com/bytedance/sonic/ast/node.go index 0d37baf12..6b5ad8a3e 100644 --- a/vendor/github.com/bytedance/sonic/ast/node.go +++ b/vendor/github.com/bytedance/sonic/ast/node.go @@ -1541,13 +1541,19 @@ var ( emptyObjectNode = Node{t: types.V_OBJECT} ) -// NewRaw creates a node of raw json, and decides its type by first char. +// NewRaw creates a node of raw json. +// If the input json is invalid, NewRaw returns a error Node. func NewRaw(json string) Node { - if json == "" { - panic("empty json string") + parser := NewParser(json) + start, err := parser.skip() + if err != 0 { + return *newError(err, err.Message()) + } + it := switchRawType(parser.s[start]) + if it == _V_NONE { + return Node{} } - it := switchRawType(json[0]) - return newRawNode(json, it) + return newRawNode(parser.s[start:parser.p], it) } // NewAny creates a node of type V_ANY if any's type isn't Node or *Node, diff --git a/vendor/github.com/bytedance/sonic/ast/parser.go b/vendor/github.com/bytedance/sonic/ast/parser.go index ebb7bb097..0a8e7b068 100644 --- a/vendor/github.com/bytedance/sonic/ast/parser.go +++ b/vendor/github.com/bytedance/sonic/ast/parser.go @@ -350,7 +350,7 @@ func (self *Parser) searchKey(match string) types.ParsingError { /* skip value */ if key != match { - if _, err = self.skip(); err != 0 { + if _, err = self.skipFast(); err != 0 { return err } } else { @@ -398,7 +398,7 @@ func (self *Parser) searchIndex(idx int) types.ParsingError { for i := 0; i < idx; i++ { /* decode the value */ - if _, err = self.skip(); err != 0 { + if _, err = self.skipFast(); err != 0 { return err } diff --git a/vendor/github.com/bytedance/sonic/bench-large.png b/vendor/github.com/bytedance/sonic/bench-large.png Binary files differdeleted file mode 100644 index 8a8785ec9..000000000 --- a/vendor/github.com/bytedance/sonic/bench-large.png +++ /dev/null diff --git a/vendor/github.com/bytedance/sonic/bench-small.png b/vendor/github.com/bytedance/sonic/bench-small.png Binary files differdeleted file mode 100644 index 7bdab77ca..000000000 --- a/vendor/github.com/bytedance/sonic/bench-small.png +++ /dev/null diff --git a/vendor/github.com/bytedance/sonic/decoder/decoder_amd64.go b/vendor/github.com/bytedance/sonic/decoder/decoder_amd64.go new file mode 100644 index 000000000..2ef19957c --- /dev/null +++ b/vendor/github.com/bytedance/sonic/decoder/decoder_amd64.go @@ -0,0 +1,66 @@ +// +build amd64,go1.15,!go1.21 + +/* +* 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 decoder + +import ( + `github.com/bytedance/sonic/internal/decoder` +) + +// Decoder is the decoder context object +type Decoder = decoder.Decoder + +type MismatchTypeError = decoder.MismatchTypeError + +// Options for decode. +type Options = decoder.Options + +const ( + OptionUseInt64 Options = decoder.OptionUseInt64 + OptionUseNumber Options = decoder.OptionUseNumber + OptionUseUnicodeErrors Options = decoder.OptionUseUnicodeErrors + OptionDisableUnknown Options = decoder.OptionDisableUnknown + OptionCopyString Options = decoder.OptionCopyString + OptionValidateString Options = decoder.OptionValidateString +) + +// StreamDecoder is the decoder context object for streaming input. +type StreamDecoder = decoder.StreamDecoder + +type SyntaxError = decoder.SyntaxError + +var ( + // NewDecoder creates a new decoder instance. + NewDecoder = decoder.NewDecoder + + // NewStreamDecoder adapts to encoding/json.NewDecoder API. + // + // NewStreamDecoder returns a new decoder that reads from r. + NewStreamDecoder = decoder.NewStreamDecoder + + // Pretouch compiles vt ahead-of-time to avoid JIT compilation on-the-fly, in + // order to reduce the first-hit latency. + // + // Opts are the compile options, for example, "option.WithCompileRecursiveDepth" is + // a compile option to set the depth of recursive compile for the nested struct type. + Pretouch = decoder.Pretouch + + // Skip skips only one json value, and returns first non-blank character position and its ending position if it is valid. + // Otherwise, returns negative error code using start and invalid character position using end + Skip = decoder.Skip +) diff --git a/vendor/github.com/bytedance/sonic/decoder/decoder_compat.go b/vendor/github.com/bytedance/sonic/decoder/decoder_compat.go new file mode 100644 index 000000000..e6b9463d7 --- /dev/null +++ b/vendor/github.com/bytedance/sonic/decoder/decoder_compat.go @@ -0,0 +1,196 @@ +// +build !amd64 go1.21 + +/* +* 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 decoder + +import ( + `encoding/json` + `bytes` + `reflect` + `github.com/bytedance/sonic/internal/native/types` + `github.com/bytedance/sonic/option` + `io` +) + +const ( + _F_use_int64 = iota + _F_use_number + _F_disable_urc + _F_disable_unknown + _F_copy_string + _F_validate_string + + _F_allow_control = 31 +) + +type Options uint64 + +const ( + OptionUseInt64 Options = 1 << _F_use_int64 + OptionUseNumber Options = 1 << _F_use_number + OptionUseUnicodeErrors Options = 1 << _F_disable_urc + OptionDisableUnknown Options = 1 << _F_disable_unknown + OptionCopyString Options = 1 << _F_copy_string + OptionValidateString Options = 1 << _F_validate_string +) + +func (self *Decoder) SetOptions(opts Options) { + if (opts & OptionUseNumber != 0) && (opts & OptionUseInt64 != 0) { + panic("can't set OptionUseInt64 and OptionUseNumber both!") + } + self.f = uint64(opts) +} + + +// Decoder is the decoder context object +type Decoder struct { + i int + f uint64 + s string +} + +// NewDecoder creates a new decoder instance. +func NewDecoder(s string) *Decoder { + return &Decoder{s: s} +} + +// Pos returns the current decoding position. +func (self *Decoder) Pos() int { + return self.i +} + +func (self *Decoder) Reset(s string) { + self.s = s + self.i = 0 + // self.f = 0 +} + +// NOTE: api fallback do nothing +func (self *Decoder) CheckTrailings() error { + pos := self.i + buf := self.s + /* skip all the trailing spaces */ + if pos != len(buf) { + for pos < len(buf) && (types.SPACE_MASK & (1 << buf[pos])) != 0 { + pos++ + } + } + + /* then it must be at EOF */ + if pos == len(buf) { + return nil + } + + /* junk after JSON value */ + return nil +} + + +// Decode parses the JSON-encoded data from current position and stores the result +// in the value pointed to by val. +func (self *Decoder) Decode(val interface{}) error { + r := bytes.NewBufferString(self.s) + dec := json.NewDecoder(r) + if (self.f | uint64(OptionUseNumber)) != 0 { + dec.UseNumber() + } + if (self.f | uint64(OptionDisableUnknown)) != 0 { + dec.DisallowUnknownFields() + } + return dec.Decode(val) +} + +// UseInt64 indicates the Decoder to unmarshal an integer into an interface{} as an +// int64 instead of as a float64. +func (self *Decoder) UseInt64() { + self.f |= 1 << _F_use_int64 + self.f &^= 1 << _F_use_number +} + +// UseNumber indicates the Decoder to unmarshal a number into an interface{} as a +// json.Number instead of as a float64. +func (self *Decoder) UseNumber() { + self.f &^= 1 << _F_use_int64 + self.f |= 1 << _F_use_number +} + +// UseUnicodeErrors indicates the Decoder to return an error when encounter invalid +// UTF-8 escape sequences. +func (self *Decoder) UseUnicodeErrors() { + self.f |= 1 << _F_disable_urc +} + +// DisallowUnknownFields indicates the Decoder to return an error when the destination +// is a struct and the input contains object keys which do not match any +// non-ignored, exported fields in the destination. +func (self *Decoder) DisallowUnknownFields() { + self.f |= 1 << _F_disable_unknown +} + +// CopyString indicates the Decoder to decode string values by copying instead of referring. +func (self *Decoder) CopyString() { + self.f |= 1 << _F_copy_string +} + +// ValidateString causes the Decoder to validate string values when decoding string value +// in JSON. Validation is that, returning error when unescaped control chars(0x00-0x1f) or +// invalid UTF-8 chars in the string value of JSON. +func (self *Decoder) ValidateString() { + self.f |= 1 << _F_validate_string +} + +// Pretouch compiles vt ahead-of-time to avoid JIT compilation on-the-fly, in +// order to reduce the first-hit latency. +// +// Opts are the compile options, for example, "option.WithCompileRecursiveDepth" is +// a compile option to set the depth of recursive compile for the nested struct type. +func Pretouch(vt reflect.Type, opts ...option.CompileOption) error { + return nil +} + +type StreamDecoder struct { + r io.Reader + buf []byte + scanp int + scanned int64 + err error + Decoder +} + +// NewStreamDecoder adapts to encoding/json.NewDecoder API. +// +// NewStreamDecoder returns a new decoder that reads from r. +func NewStreamDecoder(r io.Reader) *StreamDecoder { + return &StreamDecoder{r : r} +} + +// Decode decodes input stream into val with corresponding data. +// Redundantly bytes may be read and left in its buffer, and can be used at next call. +// Either io error from underlying io.Reader (except io.EOF) +// or syntax error from data will be recorded and stop subsequently decoding. +func (self *StreamDecoder) Decode(val interface{}) (err error) { + dec := json.NewDecoder(self.r) + if (self.f | uint64(OptionUseNumber)) != 0 { + dec.UseNumber() + } + if (self.f | uint64(OptionDisableUnknown)) != 0 { + dec.DisallowUnknownFields() + } + return dec.Decode(val) +} + diff --git a/vendor/github.com/bytedance/sonic/encoder/encoder_amd64.go b/vendor/github.com/bytedance/sonic/encoder/encoder_amd64.go new file mode 100644 index 000000000..fa107c73f --- /dev/null +++ b/vendor/github.com/bytedance/sonic/encoder/encoder_amd64.go @@ -0,0 +1,108 @@ +// +build amd64,go1.15,!go1.21 + +/* + * 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 encoder + +import ( + `github.com/bytedance/sonic/internal/encoder` +) + + +// Encoder represents a specific set of encoder configurations. +type Encoder = encoder.Encoder + +// StreamEncoder uses io.Writer as input. +type StreamEncoder = encoder.StreamEncoder + +// Options is a set of encoding options. +type Options = encoder.Options + +const ( + // SortMapKeys indicates that the keys of a map needs to be sorted + // before serializing into JSON. + // WARNING: This hurts performance A LOT, USE WITH CARE. + SortMapKeys Options = encoder.SortMapKeys + + // EscapeHTML indicates encoder to escape all HTML characters + // after serializing into JSON (see https://pkg.go.dev/encoding/json#HTMLEscape). + // WARNING: This hurts performance A LOT, USE WITH CARE. + EscapeHTML Options = encoder.EscapeHTML + + // CompactMarshaler indicates that the output JSON from json.Marshaler + // is always compact and needs no validation + CompactMarshaler Options = encoder.CompactMarshaler + + // NoQuoteTextMarshaler indicates that the output text from encoding.TextMarshaler + // is always escaped string and needs no quoting + NoQuoteTextMarshaler Options = encoder.NoQuoteTextMarshaler + + // NoNullSliceOrMap indicates all empty Array or Object are encoded as '[]' or '{}', + // instead of 'null' + NoNullSliceOrMap Options = encoder.NoNullSliceOrMap + + // ValidateString indicates that encoder should validate the input string + // before encoding it into JSON. + ValidateString Options = encoder.ValidateString + + // CompatibleWithStd is used to be compatible with std encoder. + CompatibleWithStd Options = encoder.CompatibleWithStd +) + + +var ( + // Encode returns the JSON encoding of val, encoded with opts. + Encode = encoder.Encode + + // EncodeInto is like Encode but uses a user-supplied buffer instead of allocating a new one. + EncodeIndented = encoder.EncodeIndented + + // EncodeIndented is like Encode but applies Indent to format the output. + // Each JSON element in the output will begin on a new line beginning with prefix + // followed by one or more copies of indent according to the indentation nesting. + EncodeInto = encoder.EncodeInto + + // HTMLEscape appends to dst the JSON-encoded src with <, >, &, U+2028 and U+2029 + // characters inside string literals changed to \u003c, \u003e, \u0026, \u2028, \u2029 + // so that the JSON will be safe to embed inside HTML <script> tags. + // For historical reasons, web browsers don't honor standard HTML + // escaping within <script> tags, so an alternative JSON encoding must + // be used. + HTMLEscape = encoder.HTMLEscape + + // Pretouch compiles vt ahead-of-time to avoid JIT compilation on-the-fly, in + // order to reduce the first-hit latency. + // + // Opts are the compile options, for example, "option.WithCompileRecursiveDepth" is + // a compile option to set the depth of recursive compile for the nested struct type. + Pretouch = encoder.Pretouch + + // Quote returns the JSON-quoted version of s. + Quote = encoder.Quote + + // Valid validates json and returns first non-blank character position, + // if it is only one valid json value. + // Otherwise returns invalid character position using start. + // + // Note: it does not check for the invalid UTF-8 characters. + Valid = encoder.Valid + + // NewStreamEncoder adapts to encoding/json.NewDecoder API. + // + // NewStreamEncoder returns a new encoder that write to w. + NewStreamEncoder = encoder.NewStreamEncoder +)
\ No newline at end of file diff --git a/vendor/github.com/bytedance/sonic/encoder/encoder_compat.go b/vendor/github.com/bytedance/sonic/encoder/encoder_compat.go new file mode 100644 index 000000000..afa80d561 --- /dev/null +++ b/vendor/github.com/bytedance/sonic/encoder/encoder_compat.go @@ -0,0 +1,234 @@ +// +build !amd64 go1.21 + +/* +* 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 encoder + +import ( + `io` + `bytes` + `encoding/json` + `reflect` + + `github.com/bytedance/sonic/option` +) + +// Options is a set of encoding options. +type Options uint64 + +const ( + bitSortMapKeys = iota + bitEscapeHTML + bitCompactMarshaler + bitNoQuoteTextMarshaler + bitNoNullSliceOrMap + bitValidateString + + // used for recursive compile + bitPointerValue = 63 +) + +const ( + // SortMapKeys indicates that the keys of a map needs to be sorted + // before serializing into JSON. + // WARNING: This hurts performance A LOT, USE WITH CARE. + SortMapKeys Options = 1 << bitSortMapKeys + + // EscapeHTML indicates encoder to escape all HTML characters + // after serializing into JSON (see https://pkg.go.dev/encoding/json#HTMLEscape). + // WARNING: This hurts performance A LOT, USE WITH CARE. + EscapeHTML Options = 1 << bitEscapeHTML + + // CompactMarshaler indicates that the output JSON from json.Marshaler + // is always compact and needs no validation + CompactMarshaler Options = 1 << bitCompactMarshaler + + // NoQuoteTextMarshaler indicates that the output text from encoding.TextMarshaler + // is always escaped string and needs no quoting + NoQuoteTextMarshaler Options = 1 << bitNoQuoteTextMarshaler + + // NoNullSliceOrMap indicates all empty Array or Object are encoded as '[]' or '{}', + // instead of 'null' + NoNullSliceOrMap Options = 1 << bitNoNullSliceOrMap + + // ValidateString indicates that encoder should validate the input string + // before encoding it into JSON. + ValidateString Options = 1 << bitValidateString + + // CompatibleWithStd is used to be compatible with std encoder. + CompatibleWithStd Options = SortMapKeys | EscapeHTML | CompactMarshaler +) + +// Encoder represents a specific set of encoder configurations. +type Encoder struct { + Opts Options + prefix string + indent string +} + +// Encode returns the JSON encoding of v. +func (self *Encoder) Encode(v interface{}) ([]byte, error) { + if self.indent != "" || self.prefix != "" { + return EncodeIndented(v, self.prefix, self.indent, self.Opts) + } + return Encode(v, self.Opts) +} + +// SortKeys enables the SortMapKeys option. +func (self *Encoder) SortKeys() *Encoder { + self.Opts |= SortMapKeys + return self +} + +// SetEscapeHTML specifies if option EscapeHTML opens +func (self *Encoder) SetEscapeHTML(f bool) { + if f { + self.Opts |= EscapeHTML + } else { + self.Opts &= ^EscapeHTML + } +} + +// SetValidateString specifies if option ValidateString opens +func (self *Encoder) SetValidateString(f bool) { + if f { + self.Opts |= ValidateString + } else { + self.Opts &= ^ValidateString + } +} + +// SetCompactMarshaler specifies if option CompactMarshaler opens +func (self *Encoder) SetCompactMarshaler(f bool) { + if f { + self.Opts |= CompactMarshaler + } else { + self.Opts &= ^CompactMarshaler + } +} + +// SetNoQuoteTextMarshaler specifies if option NoQuoteTextMarshaler opens +func (self *Encoder) SetNoQuoteTextMarshaler(f bool) { + if f { + self.Opts |= NoQuoteTextMarshaler + } else { + self.Opts &= ^NoQuoteTextMarshaler + } +} + +// SetIndent instructs the encoder to format each subsequent encoded +// value as if indented by the package-level function EncodeIndent(). +// Calling SetIndent("", "") disables indentation. +func (enc *Encoder) SetIndent(prefix, indent string) { + enc.prefix = prefix + enc.indent = indent +} + +// Quote returns the JSON-quoted version of s. +func Quote(s string) string { + /* check for empty string */ + if s == "" { + return `""` + } + + out, _ := json.Marshal(s) + return string(out) +} + +// Encode returns the JSON encoding of val, encoded with opts. +func Encode(val interface{}, opts Options) ([]byte, error) { + return json.Marshal(val) +} + +// EncodeInto is like Encode but uses a user-supplied buffer instead of allocating +// a new one. +func EncodeInto(buf *[]byte, val interface{}, opts Options) error { + if buf == nil { + panic("user-supplied buffer buf is nil") + } + w := bytes.NewBuffer(*buf) + enc := json.NewEncoder(w) + enc.SetEscapeHTML((opts & EscapeHTML) != 0) + err := enc.Encode(val) + *buf = w.Bytes() + return err +} + +// HTMLEscape appends to dst the JSON-encoded src with <, >, &, U+2028 and U+2029 +// characters inside string literals changed to \u003c, \u003e, \u0026, \u2028, \u2029 +// so that the JSON will be safe to embed inside HTML <script> tags. +// For historical reasons, web browsers don't honor standard HTML +// escaping within <script> tags, so an alternative JSON encoding must +// be used. +func HTMLEscape(dst []byte, src []byte) []byte { + d := bytes.NewBuffer(dst) + json.HTMLEscape(d, src) + return d.Bytes() +} + +// EncodeIndented is like Encode but applies Indent to format the output. +// Each JSON element in the output will begin on a new line beginning with prefix +// followed by one or more copies of indent according to the indentation nesting. +func EncodeIndented(val interface{}, prefix string, indent string, opts Options) ([]byte, error) { + w := bytes.NewBuffer([]byte{}) + enc := json.NewEncoder(w) + enc.SetEscapeHTML((opts & EscapeHTML) != 0) + enc.SetIndent(prefix, indent) + err := enc.Encode(val) + out := w.Bytes() + return out, err +} + +// Pretouch compiles vt ahead-of-time to avoid JIT compilation on-the-fly, in +// order to reduce the first-hit latency. +// +// Opts are the compile options, for example, "option.WithCompileRecursiveDepth" is +// a compile option to set the depth of recursive compile for the nested struct type. +func Pretouch(vt reflect.Type, opts ...option.CompileOption) error { + return nil +} + +// Valid validates json and returns first non-blank character position, +// if it is only one valid json value. +// Otherwise returns invalid character position using start. +// +// Note: it does not check for the invalid UTF-8 characters. +func Valid(data []byte) (ok bool, start int) { + return json.Valid(data), 0 +} + +// StreamEncoder uses io.Writer as +type StreamEncoder struct { + w io.Writer + Encoder +} + +// NewStreamEncoder adapts to encoding/json.NewDecoder API. +// +// NewStreamEncoder returns a new encoder that write to w. +func NewStreamEncoder(w io.Writer) *StreamEncoder { + return &StreamEncoder{w: w} +} + +// Encode encodes interface{} as JSON to io.Writer +func (enc *StreamEncoder) Encode(val interface{}) (err error) { + jenc := json.NewEncoder(enc.w) + jenc.SetEscapeHTML((enc.Opts & EscapeHTML) != 0) + jenc.SetIndent(enc.prefix, enc.indent) + err = jenc.Encode(val) + return err +} diff --git a/vendor/github.com/bytedance/sonic/decoder/asm.s b/vendor/github.com/bytedance/sonic/internal/decoder/asm.s index e69de29bb..e69de29bb 100644 --- a/vendor/github.com/bytedance/sonic/decoder/asm.s +++ b/vendor/github.com/bytedance/sonic/internal/decoder/asm.s diff --git a/vendor/github.com/bytedance/sonic/decoder/assembler_amd64_go116.go b/vendor/github.com/bytedance/sonic/internal/decoder/assembler_amd64_go116.go index 9ff1ad248..a2618bb3c 100644 --- a/vendor/github.com/bytedance/sonic/decoder/assembler_amd64_go116.go +++ b/vendor/github.com/bytedance/sonic/internal/decoder/assembler_amd64_go116.go @@ -319,6 +319,7 @@ var _OpFuncTab = [256]func(*_Assembler, *_Instr) { _OP_dismatch_err : (*_Assembler)._asm_OP_dismatch_err, _OP_go_skip : (*_Assembler)._asm_OP_go_skip, _OP_add : (*_Assembler)._asm_OP_add, + _OP_check_empty : (*_Assembler)._asm_OP_check_empty, } func (self *_Assembler) instr(v *_Instr) { @@ -458,6 +459,7 @@ var ( var ( _V_stackOverflow = jit.Imm(int64(uintptr(unsafe.Pointer(&stackOverflow)))) _I_json_UnsupportedValueError = jit.Itab(_T_error, reflect.TypeOf(new(json.UnsupportedValueError))) + _I_json_MismatchTypeError = jit.Itab(_T_error, reflect.TypeOf(new(MismatchTypeError))) ) func (self *_Assembler) type_error() { @@ -471,7 +473,12 @@ func (self *_Assembler) type_error() { func (self *_Assembler) mismatch_error() { - self.Link(_LB_mismatch_error) // _type_error: + self.Link(_LB_mismatch_error) // _type_error: + self.Emit("MOVQ", _VAR_et, _ET) // MOVQ _VAR_et, ET + self.Emit("MOVQ", _VAR_ic, _EP) // MOVQ _VAR_ic, EP + self.Emit("MOVQ", _I_json_MismatchTypeError, _AX) // MOVQ _I_json_MismatchTypeError, AX + self.Emit("CMPQ", _ET, _AX) // CMPQ ET, AX + self.Sjmp("JE" , _LB_error) // JE _LB_error self.Emit("MOVQ", _ARG_sp, _AX) self.Emit("MOVQ", _AX, jit.Ptr(_SP, 0)) // MOVQ AX, (SP) self.Emit("MOVQ", _ARG_sl, _CX) @@ -1128,9 +1135,16 @@ func (self *_Assembler) decode_dynamic(vt obj.Addr, vp obj.Addr) { self.call_go(_F_decodeTypedPointer) // CALL_GO decodeTypedPointer self.Emit("MOVQ" , jit.Ptr(_SP, 64), _ET) // MOVQ 64(SP), ET self.Emit("MOVQ" , jit.Ptr(_SP, 72), _EP) // MOVQ 72(SP), EP - self.Emit("TESTQ", _ET, _ET) // TESTQ ET, ET - self.Sjmp("JNZ" , _LB_error) // JNZ _error self.Emit("MOVQ" , jit.Ptr(_SP, 56), _IC) // MOVQ 56(SP), IC + self.Emit("TESTQ", _ET, _ET) // TESTQ ET, ET + self.Sjmp("JE", "_decode_dynamic_end_{n}") // JE, _decode_dynamic_end_{n} + self.Emit("MOVQ", _I_json_MismatchTypeError, _AX) // MOVQ _I_json_MismatchTypeError, AX + self.Emit("CMPQ", _ET, _AX) // CMPQ ET, AX + self.Sjmp("JNE" , _LB_error) // JNE LB_error + self.Emit("MOVQ", _EP, _VAR_ic) // MOVQ EP, VAR_ic + self.Emit("MOVQ", _ET, _VAR_et) // MOVQ ET, VAR_et + self.Link("_decode_dynamic_end_{n}") + } /** OpCode Assembler Functions **/ @@ -1161,6 +1175,8 @@ var ( var ( _F_FieldMap_GetCaseInsensitive obj.Addr + _Empty_Slice = make([]byte, 0) + _Zero_Base = int64(uintptr(((*rt.GoSlice)(unsafe.Pointer(&_Empty_Slice))).Ptr)) ) const ( @@ -1487,18 +1503,21 @@ func (self *_Assembler) _asm_OP_map_init(_ *_Instr) { func (self *_Assembler) _asm_OP_map_key_i8(p *_Instr) { self.parse_signed(int8Type, "", p.vi()) // PARSE int8 self.range_signed(_I_int8, _T_int8, math.MinInt8, math.MaxInt8) // RANGE int8 + self.match_char('"') self.mapassign_std(p.vt(), _VAR_st_Iv) // MAPASSIGN int8, mapassign, st.Iv } func (self *_Assembler) _asm_OP_map_key_i16(p *_Instr) { self.parse_signed(int16Type, "", p.vi()) // PARSE int16 self.range_signed(_I_int16, _T_int16, math.MinInt16, math.MaxInt16) // RANGE int16 + self.match_char('"') self.mapassign_std(p.vt(), _VAR_st_Iv) // MAPASSIGN int16, mapassign, st.Iv } func (self *_Assembler) _asm_OP_map_key_i32(p *_Instr) { self.parse_signed(int32Type, "", p.vi()) // PARSE int32 self.range_signed(_I_int32, _T_int32, math.MinInt32, math.MaxInt32) // RANGE int32 + self.match_char('"') if vt := p.vt(); !mapfast(vt) { self.mapassign_std(vt, _VAR_st_Iv) // MAPASSIGN int32, mapassign, st.Iv } else { @@ -1508,6 +1527,7 @@ func (self *_Assembler) _asm_OP_map_key_i32(p *_Instr) { func (self *_Assembler) _asm_OP_map_key_i64(p *_Instr) { self.parse_signed(int64Type, "", p.vi()) // PARSE int64 + self.match_char('"') if vt := p.vt(); !mapfast(vt) { self.mapassign_std(vt, _VAR_st_Iv) // MAPASSIGN int64, mapassign, st.Iv } else { @@ -1519,18 +1539,21 @@ func (self *_Assembler) _asm_OP_map_key_i64(p *_Instr) { func (self *_Assembler) _asm_OP_map_key_u8(p *_Instr) { self.parse_unsigned(uint8Type, "", p.vi()) // PARSE uint8 self.range_unsigned(_I_uint8, _T_uint8, math.MaxUint8) // RANGE uint8 + self.match_char('"') self.mapassign_std(p.vt(), _VAR_st_Iv) // MAPASSIGN uint8, vt.Iv } func (self *_Assembler) _asm_OP_map_key_u16(p *_Instr) { self.parse_unsigned(uint16Type, "", p.vi()) // PARSE uint16 self.range_unsigned(_I_uint16, _T_uint16, math.MaxUint16) // RANGE uint16 + self.match_char('"') self.mapassign_std(p.vt(), _VAR_st_Iv) // MAPASSIGN uint16, vt.Iv } func (self *_Assembler) _asm_OP_map_key_u32(p *_Instr) { self.parse_unsigned(uint32Type, "", p.vi()) // PARSE uint32 self.range_unsigned(_I_uint32, _T_uint32, math.MaxUint32) // RANGE uint32 + self.match_char('"') if vt := p.vt(); !mapfast(vt) { self.mapassign_std(vt, _VAR_st_Iv) // MAPASSIGN uint32, vt.Iv } else { @@ -1540,6 +1563,7 @@ func (self *_Assembler) _asm_OP_map_key_u32(p *_Instr) { func (self *_Assembler) _asm_OP_map_key_u64(p *_Instr) { self.parse_unsigned(uint64Type, "", p.vi()) // PARSE uint64 + self.match_char('"') if vt := p.vt(); !mapfast(vt) { self.mapassign_std(vt, _VAR_st_Iv) // MAPASSIGN uint64, vt.Iv } else { @@ -1552,11 +1576,13 @@ func (self *_Assembler) _asm_OP_map_key_f32(p *_Instr) { self.parse_number(float32Type, "", p.vi()) // PARSE NUMBER self.range_single() // RANGE float32 self.Emit("MOVSS", _X0, _VAR_st_Dv) // MOVSS X0, st.Dv + self.match_char('"') self.mapassign_std(p.vt(), _VAR_st_Dv) // MAPASSIGN ${p.vt()}, mapassign, st.Dv } func (self *_Assembler) _asm_OP_map_key_f64(p *_Instr) { self.parse_number(float64Type, "", p.vi()) // PARSE NUMBER + self.match_char('"') self.mapassign_std(p.vt(), _VAR_st_Dv) // MAPASSIGN ${p.vt()}, mapassign, st.Dv } @@ -1621,6 +1647,24 @@ func (self *_Assembler) _asm_OP_slice_init(p *_Instr) { self.Emit("MOVQ" , _AX, jit.Ptr(_VP, 8)) // MOVQ AX, 8(VP) } +func (self *_Assembler) _asm_OP_check_empty(p *_Instr) { + rbracket := p.vb() + if rbracket == ']' { + self.check_eof(1) + self.Emit("LEAQ", jit.Ptr(_IC, 1), _AX) // LEAQ 1(IC), AX + self.Emit("CMPB", jit.Sib(_IP, _IC, 1, 0), jit.Imm(int64(rbracket))) // CMPB (IP)(IC), ']' + self.Sjmp("JNE" , "_not_empty_array_{n}") // JNE _not_empty_array_{n} + self.Emit("MOVQ", _AX, _IC) // MOVQ AX, IC + self.StorePtr(_Zero_Base, jit.Ptr(_VP, 0), _AX) // MOVQ $zerobase, (VP) + self.Emit("PXOR" , _X0, _X0) // PXOR X0, X0 + self.Emit("MOVOU", _X0, jit.Ptr(_VP, 8)) // MOVOU X0, 8(VP) + self.Xjmp("JMP" , p.vi()) // JMP {p.vi()} + self.Link("_not_empty_array_{n}") + } else { + panic("only implement check empty array here!") + } +} + func (self *_Assembler) _asm_OP_slice_append(p *_Instr) { self.Emit("MOVQ" , jit.Ptr(_VP, 8), _AX) // MOVQ 8(VP), AX self.Emit("CMPQ" , _AX, jit.Ptr(_VP, 16)) // CMPQ AX, 16(VP) @@ -1640,12 +1684,34 @@ func (self *_Assembler) _asm_OP_slice_append(p *_Instr) { self.WriteRecNotAX(8, _DI, jit.Ptr(_VP, 0), true, true)// MOVQ DI, (VP) self.Emit("MOVQ" , _AX, jit.Ptr(_VP, 8)) // MOVQ AX, 8(VP) self.Emit("MOVQ" , _SI, jit.Ptr(_VP, 16)) // MOVQ SI, 16(VP) + + // because growslice not zero memory {oldcap, newlen} when append et not has ptrdata. + // but we should zero it, avoid decode it as random values. + if rt.UnpackType(p.vt()).PtrData == 0 { + self.Emit("SUBQ" , _AX, _SI) // MOVQ AX, SI + + self.Emit("ADDQ" , jit.Imm(1), jit.Ptr(_VP, 8)) // ADDQ $1, 8(VP) + self.Emit("MOVQ" , _DI, _VP) // MOVQ DI, VP + self.Emit("MOVQ" , jit.Imm(int64(p.vlen())), _CX) // MOVQ ${p.vlen()}, CX + self.From("MULQ" , _CX) // MULQ CX + self.Emit("ADDQ" , _AX, _VP) // ADDQ AX, VP + + self.Emit("MOVQ" , _SI, _AX) // MOVQ SI, AX + self.From("MULQ" , _CX) // MULQ CX + self.Emit("MOVQ" , _AX, jit.Ptr(_SP, 8)) // MOVQ AX, 8(SP) + + self.Emit("MOVQ" , _VP, jit.Ptr(_SP, 0)) // MOVQ VP, (SP) + self.mem_clear_fn(true) // CALL_GO memclr{Has,NoHeap} + self.Sjmp("JMP", "_append_slice_end_{n}") // JMP _append_slice_end_{n} + } + self.Link("_index_{n}") // _index_{n}: self.Emit("ADDQ" , jit.Imm(1), jit.Ptr(_VP, 8)) // ADDQ $1, 8(VP) self.Emit("MOVQ" , jit.Ptr(_VP, 0), _VP) // MOVQ (VP), VP self.Emit("MOVQ" , jit.Imm(int64(p.vlen())), _CX) // MOVQ ${p.vlen()}, CX self.From("MULQ" , _CX) // MULQ CX self.Emit("ADDQ" , _AX, _VP) // ADDQ AX, VP + self.Link("_append_slice_end_{n}") } func (self *_Assembler) _asm_OP_object_skip(_ *_Instr) { @@ -1787,10 +1853,14 @@ func (self *_Assembler) lspace(subfix string) { } func (self *_Assembler) _asm_OP_match_char(p *_Instr) { + self.match_char(p.vb()) +} + +func (self *_Assembler) match_char(char byte) { self.check_eof(1) - self.Emit("CMPB", jit.Sib(_IP, _IC, 1, 0), jit.Imm(int64(p.vb()))) // CMPB (IP)(IC), ${p.vb()} - self.Sjmp("JNE" , _LB_char_0_error) // JNE _char_0_error - self.Emit("ADDQ", jit.Imm(1), _IC) // ADDQ $1, IC + self.Emit("CMPB", jit.Sib(_IP, _IC, 1, 0), jit.Imm(int64(char))) // CMPB (IP)(IC), ${p.vb()} + self.Sjmp("JNE" , _LB_char_0_error) // JNE _char_0_error + self.Emit("ADDQ", jit.Imm(1), _IC) // ADDQ $1, IC } func (self *_Assembler) _asm_OP_check_char(p *_Instr) { diff --git a/vendor/github.com/bytedance/sonic/decoder/assembler_amd64_go117.go b/vendor/github.com/bytedance/sonic/internal/decoder/assembler_amd64_go117.go index 8a70cfff6..27413739d 100644 --- a/vendor/github.com/bytedance/sonic/decoder/assembler_amd64_go117.go +++ b/vendor/github.com/bytedance/sonic/internal/decoder/assembler_amd64_go117.go @@ -315,6 +315,7 @@ var _OpFuncTab = [256]func(*_Assembler, *_Instr) { _OP_dismatch_err : (*_Assembler)._asm_OP_dismatch_err, _OP_go_skip : (*_Assembler)._asm_OP_go_skip, _OP_add : (*_Assembler)._asm_OP_add, + _OP_check_empty : (*_Assembler)._asm_OP_check_empty, _OP_debug : (*_Assembler)._asm_OP_debug, } @@ -348,8 +349,8 @@ func (self *_Assembler) epilogue() { self.Emit("MOVQ", _EP, _CX) // MOVQ BX, CX self.Emit("MOVQ", _ET, _BX) // MOVQ AX, BX self.Emit("MOVQ", _IC, _AX) // MOVQ IC, AX - self.Emit("MOVQ", jit.Imm(0), _ARG_sp) // MOVQ $0, sv.p<>+48(FP) - self.Emit("MOVQ", jit.Imm(0), _ARG_vp) // MOVQ $0, sv.p<>+48(FP) + self.Emit("MOVQ", jit.Imm(0), _ARG_sp) // MOVQ $0, sv.p<>+48(FP) + self.Emit("MOVQ", jit.Imm(0), _ARG_vp) // MOVQ $0, sv.p<>+48(FP) self.Emit("MOVQ", jit.Imm(0), _ARG_sv_p) // MOVQ $0, sv.p<>+48(FP) self.Emit("MOVQ", jit.Imm(0), _ARG_vk) // MOVQ $0, vk<>+64(FP) self.Emit("MOVQ", jit.Ptr(_SP, _FP_offs), _BP) // MOVQ _FP_offs(SP), BP @@ -480,6 +481,7 @@ var ( var ( _V_stackOverflow = jit.Imm(int64(uintptr(unsafe.Pointer(&stackOverflow)))) _I_json_UnsupportedValueError = jit.Itab(_T_error, reflect.TypeOf(new(json.UnsupportedValueError))) + _I_json_MismatchTypeError = jit.Itab(_T_error, reflect.TypeOf(new(MismatchTypeError))) ) func (self *_Assembler) type_error() { @@ -489,7 +491,12 @@ func (self *_Assembler) type_error() { } func (self *_Assembler) mismatch_error() { - self.Link(_LB_mismatch_error) // _type_error: + self.Link(_LB_mismatch_error) // _type_error: + self.Emit("MOVQ", _VAR_et, _ET) // MOVQ _VAR_et, ET + self.Emit("MOVQ", _VAR_ic, _EP) // MOVQ _VAR_ic, EP + self.Emit("MOVQ", _I_json_MismatchTypeError, _CX) // MOVQ _I_json_MismatchType, CX + self.Emit("CMPQ", _ET, _CX) // CMPQ ET, CX + self.Sjmp("JE" , _LB_error) // JE _LB_error self.Emit("MOVQ", _ARG_sp, _AX) self.Emit("MOVQ", _ARG_sl, _BX) self.Emit("MOVQ", _VAR_ic, _CX) @@ -1119,7 +1126,7 @@ func (self *_Assembler) decode_dynamic(vt obj.Addr, vp obj.Addr) { self.Emit("MOVQ", _ARG_sp, _AX) // MOVQ sp, AX self.Emit("MOVQ", _ARG_sl, _BX) // MOVQ sp, BX self.Emit("MOVQ" , _IC, _CX) // MOVQ IC, CX - self.Emit("MOVQ" , _ST, _R8) // MOVQ ST, R8 + self.Emit("MOVQ" , _ST, _R8) // MOVQ ST, R8 self.Emit("MOVQ" , _ARG_fv, _R9) // MOVQ fv, R9 self.save(_REG_rt...) self.Emit("MOVQ", _F_decodeTypedPointer, _IL) // MOVQ ${fn}, R11 @@ -1129,7 +1136,13 @@ func (self *_Assembler) decode_dynamic(vt obj.Addr, vp obj.Addr) { self.Emit("MOVQ" , _BX, _ET) // MOVQ BX, ET self.Emit("MOVQ" , _CX, _EP) // MOVQ CX, EP self.Emit("TESTQ", _ET, _ET) // TESTQ ET, ET - self.Sjmp("JNZ" , _LB_error) // JNZ _error + self.Sjmp("JE", "_decode_dynamic_end_{n}") // JE, _decode_dynamic_end_{n} + self.Emit("MOVQ", _I_json_MismatchTypeError, _CX) // MOVQ _I_json_MismatchTypeError, CX + self.Emit("CMPQ", _ET, _CX) // CMPQ ET, CX + self.Sjmp("JNE", _LB_error) // JNE LB_error + self.Emit("MOVQ", _EP, _VAR_ic) // MOVQ EP, VAR_ic + self.Emit("MOVQ", _ET, _VAR_et) // MOVQ ET, VAR_et + self.Link("_decode_dynamic_end_{n}") } /** OpCode Assembler Functions **/ @@ -1155,6 +1168,8 @@ var ( var ( _F_FieldMap_GetCaseInsensitive obj.Addr + _Empty_Slice = make([]byte, 0) + _Zero_Base = int64(uintptr(((*rt.GoSlice)(unsafe.Pointer(&_Empty_Slice))).Ptr)) ) const ( @@ -1482,18 +1497,21 @@ func (self *_Assembler) _asm_OP_map_init(_ *_Instr) { func (self *_Assembler) _asm_OP_map_key_i8(p *_Instr) { self.parse_signed(int8Type, "", p.vi()) // PARSE int8 self.range_signed_CX(_I_int8, _T_int8, math.MinInt8, math.MaxInt8) // RANGE int8 + self.match_char('"') self.mapassign_std(p.vt(), _VAR_st_Iv) // MAPASSIGN int8, mapassign, st.Iv } func (self *_Assembler) _asm_OP_map_key_i16(p *_Instr) { self.parse_signed(int16Type, "", p.vi()) // PARSE int16 self.range_signed_CX(_I_int16, _T_int16, math.MinInt16, math.MaxInt16) // RANGE int16 + self.match_char('"') self.mapassign_std(p.vt(), _VAR_st_Iv) // MAPASSIGN int16, mapassign, st.Iv } func (self *_Assembler) _asm_OP_map_key_i32(p *_Instr) { self.parse_signed(int32Type, "", p.vi()) // PARSE int32 self.range_signed_CX(_I_int32, _T_int32, math.MinInt32, math.MaxInt32) // RANGE int32 + self.match_char('"') if vt := p.vt(); !mapfast(vt) { self.mapassign_std(vt, _VAR_st_Iv) // MAPASSIGN int32, mapassign, st.Iv } else { @@ -1504,6 +1522,7 @@ func (self *_Assembler) _asm_OP_map_key_i32(p *_Instr) { func (self *_Assembler) _asm_OP_map_key_i64(p *_Instr) { self.parse_signed(int64Type, "", p.vi()) // PARSE int64 + self.match_char('"') if vt := p.vt(); !mapfast(vt) { self.mapassign_std(vt, _VAR_st_Iv) // MAPASSIGN int64, mapassign, st.Iv } else { @@ -1515,18 +1534,21 @@ func (self *_Assembler) _asm_OP_map_key_i64(p *_Instr) { func (self *_Assembler) _asm_OP_map_key_u8(p *_Instr) { self.parse_unsigned(uint8Type, "", p.vi()) // PARSE uint8 self.range_unsigned_CX(_I_uint8, _T_uint8, math.MaxUint8) // RANGE uint8 - self.mapassign_std(p.vt(), _VAR_st_Iv) // MAPASSIGN uint8, vt.Iv + self.match_char('"') + self.mapassign_std(p.vt(), _VAR_st_Iv) // MAPASSIGN uint8, vt.Iv } func (self *_Assembler) _asm_OP_map_key_u16(p *_Instr) { self.parse_unsigned(uint16Type, "", p.vi()) // PARSE uint16 self.range_unsigned_CX(_I_uint16, _T_uint16, math.MaxUint16) // RANGE uint16 + self.match_char('"') self.mapassign_std(p.vt(), _VAR_st_Iv) // MAPASSIGN uint16, vt.Iv } func (self *_Assembler) _asm_OP_map_key_u32(p *_Instr) { self.parse_unsigned(uint32Type, "", p.vi()) // PARSE uint32 self.range_unsigned_CX(_I_uint32, _T_uint32, math.MaxUint32) // RANGE uint32 + self.match_char('"') if vt := p.vt(); !mapfast(vt) { self.mapassign_std(vt, _VAR_st_Iv) // MAPASSIGN uint32, vt.Iv } else { @@ -1537,6 +1559,7 @@ func (self *_Assembler) _asm_OP_map_key_u32(p *_Instr) { func (self *_Assembler) _asm_OP_map_key_u64(p *_Instr) { self.parse_unsigned(uint64Type, "", p.vi()) // PARSE uint64 + self.match_char('"') if vt := p.vt(); !mapfast(vt) { self.mapassign_std(vt, _VAR_st_Iv) // MAPASSIGN uint64, vt.Iv } else { @@ -1549,11 +1572,13 @@ func (self *_Assembler) _asm_OP_map_key_f32(p *_Instr) { self.parse_number(float32Type, "", p.vi()) // PARSE NUMBER self.range_single_X0() // RANGE float32 self.Emit("MOVSS", _X0, _VAR_st_Dv) // MOVSS X0, st.Dv + self.match_char('"') self.mapassign_std(p.vt(), _VAR_st_Dv) // MAPASSIGN ${p.vt()}, mapassign, st.Dv } func (self *_Assembler) _asm_OP_map_key_f64(p *_Instr) { self.parse_number(float64Type, "", p.vi()) // PARSE NUMBER + self.match_char('"') self.mapassign_std(p.vt(), _VAR_st_Dv) // MAPASSIGN ${p.vt()}, mapassign, st.Dv } @@ -1612,6 +1637,24 @@ func (self *_Assembler) _asm_OP_slice_init(p *_Instr) { self.Link("_done_{n}") // _done_{n} } +func (self *_Assembler) _asm_OP_check_empty(p *_Instr) { + rbracket := p.vb() + if rbracket == ']' { + self.check_eof(1) + self.Emit("LEAQ", jit.Ptr(_IC, 1), _AX) // LEAQ 1(IC), AX + self.Emit("CMPB", jit.Sib(_IP, _IC, 1, 0), jit.Imm(int64(rbracket))) // CMPB (IP)(IC), ']' + self.Sjmp("JNE" , "_not_empty_array_{n}") // JNE _not_empty_array_{n} + self.Emit("MOVQ", _AX, _IC) // MOVQ AX, IC + self.StorePtr(_Zero_Base, jit.Ptr(_VP, 0), _AX) // MOVQ $zerobase, (VP) + self.Emit("PXOR", _X0, _X0) // PXOR X0, X0 + self.Emit("MOVOU", _X0, jit.Ptr(_VP, 8)) // MOVOU X0, 8(VP) + self.Xjmp("JMP" , p.vi()) // JMP {p.vi()} + self.Link("_not_empty_array_{n}") + } else { + panic("only implement check empty array here!") + } +} + func (self *_Assembler) _asm_OP_slice_append(p *_Instr) { self.Emit("MOVQ" , jit.Ptr(_VP, 8), _AX) // MOVQ 8(VP), AX self.Emit("CMPQ" , _AX, jit.Ptr(_VP, 16)) // CMPQ AX, 16(VP) @@ -1626,6 +1669,28 @@ func (self *_Assembler) _asm_OP_slice_append(p *_Instr) { self.WritePtrAX(8, jit.Ptr(_VP, 0), false) // MOVQ AX, (VP) self.Emit("MOVQ" , _BX, jit.Ptr(_VP, 8)) // MOVQ BX, 8(VP) self.Emit("MOVQ" , _CX, jit.Ptr(_VP, 16)) // MOVQ CX, 16(VP) + + // because growslice not zero memory {oldcap, newlen} when append et not has ptrdata. + // but we should zero it, avoid decode it as random values. + if rt.UnpackType(p.vt()).PtrData == 0 { + self.Emit("MOVQ" , _CX, _DI) // MOVQ CX, DI + self.Emit("SUBQ" , _BX, _DI) // MOVQ BX, DI + + self.Emit("ADDQ" , jit.Imm(1), jit.Ptr(_VP, 8)) // ADDQ $1, 8(VP) + self.Emit("MOVQ" , _AX, _VP) // MOVQ AX, VP + self.Emit("MOVQ" , jit.Imm(int64(p.vlen())), _CX) // MOVQ ${p.vlen()}, CX + self.Emit("MOVQ" , _BX, _AX) // MOVQ BX, AX + self.From("MULQ" , _CX) // MULQ CX + self.Emit("ADDQ" , _AX, _VP) // ADDQ AX, VP + + self.Emit("MOVQ" , _DI, _AX) // MOVQ SI, AX + self.From("MULQ" , _CX) // MULQ BX + self.Emit("MOVQ" , _AX, _BX) // ADDQ AX, BX + self.Emit("MOVQ" , _VP, _AX) // MOVQ VP, AX + self.mem_clear_fn(true) // CALL_GO memclr{Has,NoHeap} + self.Sjmp("JMP", "_append_slice_end_{n}") + } + self.Emit("MOVQ" , _BX, _AX) // MOVQ BX, AX self.Link("_index_{n}") // _index_{n}: self.Emit("ADDQ" , jit.Imm(1), jit.Ptr(_VP, 8)) // ADDQ $1, 8(VP) @@ -1633,6 +1698,7 @@ func (self *_Assembler) _asm_OP_slice_append(p *_Instr) { self.Emit("MOVQ" , jit.Imm(int64(p.vlen())), _CX) // MOVQ ${p.vlen()}, CX self.From("MULQ" , _CX) // MULQ CX self.Emit("ADDQ" , _AX, _VP) // ADDQ AX, VP + self.Link("_append_slice_end_{n}") } func (self *_Assembler) _asm_OP_object_skip(_ *_Instr) { @@ -1767,8 +1833,12 @@ func (self *_Assembler) lspace(subfix string) { } func (self *_Assembler) _asm_OP_match_char(p *_Instr) { + self.match_char(p.vb()) +} + +func (self *_Assembler) match_char(char byte) { self.check_eof(1) - self.Emit("CMPB", jit.Sib(_IP, _IC, 1, 0), jit.Imm(int64(p.vb()))) // CMPB (IP)(IC), ${p.vb()} + self.Emit("CMPB", jit.Sib(_IP, _IC, 1, 0), jit.Imm(int64(char))) // CMPB (IP)(IC), ${p.vb()} self.Sjmp("JNE" , _LB_char_0_error) // JNE _char_0_error self.Emit("ADDQ", jit.Imm(1), _IC) // ADDQ $1, IC } diff --git a/vendor/github.com/bytedance/sonic/decoder/compiler.go b/vendor/github.com/bytedance/sonic/internal/decoder/compiler.go index b4fc2fed2..8f3905fca 100644 --- a/vendor/github.com/bytedance/sonic/decoder/compiler.go +++ b/vendor/github.com/bytedance/sonic/internal/decoder/compiler.go @@ -98,6 +98,7 @@ const ( _OP_dismatch_err _OP_go_skip _OP_add + _OP_check_empty _OP_debug ) @@ -174,6 +175,9 @@ var _OpNames = [256]string { _OP_check_char_0 : "check_char_0", _OP_dismatch_err : "dismatch_err", _OP_add : "add", + _OP_go_skip : "go_skip", + _OP_check_empty : "check_empty", + _OP_debug : "debug", } func (self _Op) String() string { @@ -639,11 +643,6 @@ func (self *_Compiler) compileMapOp(p *_Program, sp int, vt reflect.Type, op _Op skip2 := p.pc() p.rtt(op, vt) - /* match the closing quote if needed */ - if op != _OP_map_key_str && op != _OP_map_key_utext && op != _OP_map_key_utext_p { - p.chr(_OP_match_char, '"') - } - /* match the value separator */ p.add(_OP_lspace) p.chr(_OP_match_char, ':') @@ -660,11 +659,6 @@ func (self *_Compiler) compileMapOp(p *_Program, sp int, vt reflect.Type, op _Op skip3 := p.pc() p.rtt(op, vt) - /* match the closing quote if needed */ - if op != _OP_map_key_str && op != _OP_map_key_utext && op != _OP_map_key_utext_p { - p.chr(_OP_match_char, '"') - } - /* match the value separator */ p.add(_OP_lspace) p.chr(_OP_match_char, ':') @@ -689,12 +683,37 @@ func (self *_Compiler) compilePtr(p *_Program, sp int, et reflect.Type) { /* dereference all the way down */ for et.Kind() == reflect.Ptr { + if et.Implements(jsonUnmarshalerType) { + p.rtt(_OP_unmarshal_p, et) + return + } + + if et.Implements(encodingTextUnmarshalerType) { + p.add(_OP_lspace) + self.compileUnmarshalTextPtr(p, et) + return + } + et = et.Elem() p.rtt(_OP_deref, et) } - /* compile the element type */ - self.compileOne(p, sp + 1, et) + /* check for recursive nesting */ + ok := self.tab[et] + if ok { + p.rtt(_OP_recurse, et) + } else { + /* enter the recursion */ + p.add(_OP_lspace) + self.tab[et] = true + + /* not inline the pointer type + * recursing the defined pointer type's elem will casue issue379. + */ + self.compileOps(p, sp, et) + } + delete(self.tab, et) + j := p.pc() p.add(_OP_goto) p.pin(i) @@ -791,11 +810,11 @@ func (self *_Compiler) compileSliceList(p *_Program, sp int, vt reflect.Type) { } func (self *_Compiler) compileSliceBody(p *_Program, sp int, et reflect.Type) { - p.rtt(_OP_slice_init, et) - p.add(_OP_save) p.add(_OP_lspace) j := p.pc() - p.chr(_OP_check_char, ']') + p.chr(_OP_check_empty, ']') + p.rtt(_OP_slice_init, et) + p.add(_OP_save) p.rtt(_OP_slice_append, et) self.compileOne(p, sp + 1, et) p.add(_OP_load) @@ -808,9 +827,9 @@ func (self *_Compiler) compileSliceBody(p *_Program, sp int, et reflect.Type) { self.compileOne(p, sp + 1, et) p.add(_OP_load) p.int(_OP_goto, k0) - p.pin(j) p.pin(k1) p.add(_OP_drop) + p.pin(j) } func (self *_Compiler) compileString(p *_Program, vt reflect.Type) { diff --git a/vendor/github.com/bytedance/sonic/decoder/debug.go b/vendor/github.com/bytedance/sonic/internal/decoder/debug.go index 9cf3a6a00..9cf3a6a00 100644 --- a/vendor/github.com/bytedance/sonic/decoder/debug.go +++ b/vendor/github.com/bytedance/sonic/internal/decoder/debug.go diff --git a/vendor/github.com/bytedance/sonic/decoder/decoder.go b/vendor/github.com/bytedance/sonic/internal/decoder/decoder.go index 5326f9728..19ad71965 100644 --- a/vendor/github.com/bytedance/sonic/decoder/decoder.go +++ b/vendor/github.com/bytedance/sonic/internal/decoder/decoder.go @@ -17,6 +17,7 @@ package decoder import ( + `unsafe` `encoding/json` `reflect` `runtime` @@ -127,8 +128,17 @@ func (self *Decoder) Decode(val interface{}) error { return &json.InvalidUnmarshalError{Type: vv.Type.Pack()} } + etp := rt.PtrElem(vv.Type) + + /* check the defined pointer type for issue 379 */ + if vv.Type.IsNamed() { + newp := vp + etp = vv.Type + vp = unsafe.Pointer(&newp) + } + /* create a new stack, and call the decoder */ - sb, etp := newStack(), rt.PtrElem(vv.Type) + sb := newStack() nb, err := decodeTypedPointer(self.s, self.i, etp, vp, sb, self.f) /* return the stack back */ self.i = nb diff --git a/vendor/github.com/bytedance/sonic/decoder/errors.go b/vendor/github.com/bytedance/sonic/internal/decoder/errors.go index c905fdfb0..c905fdfb0 100644 --- a/vendor/github.com/bytedance/sonic/decoder/errors.go +++ b/vendor/github.com/bytedance/sonic/internal/decoder/errors.go diff --git a/vendor/github.com/bytedance/sonic/decoder/generic_amd64_go116.go b/vendor/github.com/bytedance/sonic/internal/decoder/generic_amd64_go116.go index b597043f9..b597043f9 100644 --- a/vendor/github.com/bytedance/sonic/decoder/generic_amd64_go116.go +++ b/vendor/github.com/bytedance/sonic/internal/decoder/generic_amd64_go116.go diff --git a/vendor/github.com/bytedance/sonic/decoder/generic_amd64_go117.go b/vendor/github.com/bytedance/sonic/internal/decoder/generic_amd64_go117.go index df1cd9f5b..df1cd9f5b 100644 --- a/vendor/github.com/bytedance/sonic/decoder/generic_amd64_go117.go +++ b/vendor/github.com/bytedance/sonic/internal/decoder/generic_amd64_go117.go diff --git a/vendor/github.com/bytedance/sonic/decoder/generic_amd64_go117_test.s b/vendor/github.com/bytedance/sonic/internal/decoder/generic_amd64_go117_test.s index 6c2686de9..6c2686de9 100644 --- a/vendor/github.com/bytedance/sonic/decoder/generic_amd64_go117_test.s +++ b/vendor/github.com/bytedance/sonic/internal/decoder/generic_amd64_go117_test.s diff --git a/vendor/github.com/bytedance/sonic/decoder/generic_amd64_test.s b/vendor/github.com/bytedance/sonic/internal/decoder/generic_amd64_test.s index 36cb1f5f3..36cb1f5f3 100644 --- a/vendor/github.com/bytedance/sonic/decoder/generic_amd64_test.s +++ b/vendor/github.com/bytedance/sonic/internal/decoder/generic_amd64_test.s diff --git a/vendor/github.com/bytedance/sonic/decoder/pools.go b/vendor/github.com/bytedance/sonic/internal/decoder/pools.go index ab1e5f23c..06adc7fa1 100644 --- a/vendor/github.com/bytedance/sonic/decoder/pools.go +++ b/vendor/github.com/bytedance/sonic/internal/decoder/pools.go @@ -26,7 +26,7 @@ import ( ) const ( - _MinSlice = 16 + _MinSlice = 2 _MaxStack = 4096 // 4k slots _MaxStackBytes = _MaxStack * _PtrBytes _MaxDigitNums = 800 // used in atof fallback algorithm diff --git a/vendor/github.com/bytedance/sonic/decoder/primitives.go b/vendor/github.com/bytedance/sonic/internal/decoder/primitives.go index d6053e2cb..d6053e2cb 100644 --- a/vendor/github.com/bytedance/sonic/decoder/primitives.go +++ b/vendor/github.com/bytedance/sonic/internal/decoder/primitives.go diff --git a/vendor/github.com/bytedance/sonic/decoder/stream.go b/vendor/github.com/bytedance/sonic/internal/decoder/stream.go index 06dc8185b..e1e0f73b9 100644 --- a/vendor/github.com/bytedance/sonic/decoder/stream.go +++ b/vendor/github.com/bytedance/sonic/internal/decoder/stream.go @@ -21,15 +21,15 @@ import ( `io` `sync` + `github.com/bytedance/sonic/option` `github.com/bytedance/sonic/internal/native/types` ) var ( - defaultBufferSize uint = 4096 - growSliceFactorShift uint = 1 - minLeftBufferShift uint = 2 + minLeftBufferShift uint = 1 ) +// StreamDecoder is the decoder context object for streaming input. type StreamDecoder struct { r io.Reader buf []byte @@ -41,7 +41,7 @@ type StreamDecoder struct { var bufPool = sync.Pool{ New: func () interface{} { - return make([]byte, 0, defaultBufferSize) + return make([]byte, 0, option.DefaultDecoderBufferSize) }, } @@ -206,8 +206,8 @@ func realloc(buf *[]byte) { c := uint(cap(*buf)) if c - l <= c >> minLeftBufferShift { e := l+(l>>minLeftBufferShift) - if e < defaultBufferSize { - e = defaultBufferSize + if e < option.DefaultDecoderBufferSize { + e = option.DefaultDecoderBufferSize } tmp := make([]byte, l, e) copy(tmp, *buf) diff --git a/vendor/github.com/bytedance/sonic/decoder/stubs_go115.go b/vendor/github.com/bytedance/sonic/internal/decoder/stubs_go115.go index 1a0917c3c..1a0917c3c 100644 --- a/vendor/github.com/bytedance/sonic/decoder/stubs_go115.go +++ b/vendor/github.com/bytedance/sonic/internal/decoder/stubs_go115.go diff --git a/vendor/github.com/bytedance/sonic/decoder/stubs_go120.go b/vendor/github.com/bytedance/sonic/internal/decoder/stubs_go120.go index cde6a1972..cde6a1972 100644 --- a/vendor/github.com/bytedance/sonic/decoder/stubs_go120.go +++ b/vendor/github.com/bytedance/sonic/internal/decoder/stubs_go120.go diff --git a/vendor/github.com/bytedance/sonic/decoder/types.go b/vendor/github.com/bytedance/sonic/internal/decoder/types.go index 6fc0e706c..6fc0e706c 100644 --- a/vendor/github.com/bytedance/sonic/decoder/types.go +++ b/vendor/github.com/bytedance/sonic/internal/decoder/types.go diff --git a/vendor/github.com/bytedance/sonic/decoder/utils.go b/vendor/github.com/bytedance/sonic/internal/decoder/utils.go index 23ee5d501..23ee5d501 100644 --- a/vendor/github.com/bytedance/sonic/decoder/utils.go +++ b/vendor/github.com/bytedance/sonic/internal/decoder/utils.go diff --git a/vendor/github.com/bytedance/sonic/encoder/asm.s b/vendor/github.com/bytedance/sonic/internal/encoder/asm.s index e69de29bb..e69de29bb 100644 --- a/vendor/github.com/bytedance/sonic/encoder/asm.s +++ b/vendor/github.com/bytedance/sonic/internal/encoder/asm.s diff --git a/vendor/github.com/bytedance/sonic/encoder/assembler_amd64_go116.go b/vendor/github.com/bytedance/sonic/internal/encoder/assembler_amd64_go116.go index 9b5978431..d056259f2 100644 --- a/vendor/github.com/bytedance/sonic/encoder/assembler_amd64_go116.go +++ b/vendor/github.com/bytedance/sonic/internal/encoder/assembler_amd64_go116.go @@ -514,7 +514,8 @@ func (self *_Assembler) call_marshaler(fn obj.Addr, it *rt.GoType, vt reflect.Ty switch vt.Kind() { case reflect.Interface : self.call_marshaler_i(fn, it) case reflect.Ptr, reflect.Map: self.call_marshaler_v(fn, it, vt, true) - default : self.call_marshaler_v(fn, it, vt, false) + // struct/array of 1 direct iface type can be direct + default : self.call_marshaler_v(fn, it, vt, !rt.UnpackType(vt).Indirect()) } } diff --git a/vendor/github.com/bytedance/sonic/encoder/assembler_amd64_go117.go b/vendor/github.com/bytedance/sonic/internal/encoder/assembler_amd64_go117.go index 8cd83e868..1f1b28073 100644 --- a/vendor/github.com/bytedance/sonic/encoder/assembler_amd64_go117.go +++ b/vendor/github.com/bytedance/sonic/internal/encoder/assembler_amd64_go117.go @@ -539,7 +539,8 @@ func (self *_Assembler) call_marshaler(fn obj.Addr, it *rt.GoType, vt reflect.Ty switch vt.Kind() { case reflect.Interface : self.call_marshaler_i(fn, it) case reflect.Ptr, reflect.Map : self.call_marshaler_v(fn, it, vt, true) - default : self.call_marshaler_v(fn, it, vt, false) + // struct/array of 1 direct iface type can be direct + default : self.call_marshaler_v(fn, it, vt, !rt.UnpackType(vt).Indirect()) } } diff --git a/vendor/github.com/bytedance/sonic/encoder/compiler.go b/vendor/github.com/bytedance/sonic/internal/encoder/compiler.go index a949c90f7..a949c90f7 100644 --- a/vendor/github.com/bytedance/sonic/encoder/compiler.go +++ b/vendor/github.com/bytedance/sonic/internal/encoder/compiler.go diff --git a/vendor/github.com/bytedance/sonic/encoder/debug_go116.go b/vendor/github.com/bytedance/sonic/internal/encoder/debug_go116.go index 4bc9c15c1..4bc9c15c1 100644 --- a/vendor/github.com/bytedance/sonic/encoder/debug_go116.go +++ b/vendor/github.com/bytedance/sonic/internal/encoder/debug_go116.go diff --git a/vendor/github.com/bytedance/sonic/encoder/debug_go117.go b/vendor/github.com/bytedance/sonic/internal/encoder/debug_go117.go index e1016de32..e1016de32 100644 --- a/vendor/github.com/bytedance/sonic/encoder/debug_go117.go +++ b/vendor/github.com/bytedance/sonic/internal/encoder/debug_go117.go diff --git a/vendor/github.com/bytedance/sonic/encoder/encoder.go b/vendor/github.com/bytedance/sonic/internal/encoder/encoder.go index 7a1330166..3c46061a4 100644 --- a/vendor/github.com/bytedance/sonic/encoder/encoder.go +++ b/vendor/github.com/bytedance/sonic/internal/encoder/encoder.go @@ -21,6 +21,7 @@ import ( `encoding/json` `reflect` `runtime` + `unsafe` `github.com/bytedance/sonic/internal/native` `github.com/bytedance/sonic/internal/native/types` @@ -161,8 +162,10 @@ func Quote(s string) string { // Encode returns the JSON encoding of val, encoded with opts. func Encode(val interface{}, opts Options) ([]byte, error) { + var ret []byte + buf := newBytes() - err := EncodeInto(&buf, val, opts) + err := encodeInto(&buf, val, opts) /* check for errors */ if err != nil { @@ -170,12 +173,20 @@ func Encode(val interface{}, opts Options) ([]byte, error) { return nil, err } - if opts & EscapeHTML != 0 || opts & ValidateString != 0 { + /* htmlescape or correct UTF-8 if opts enable */ + old := buf + buf = encodeFinish(old, opts) + pbuf := ((*rt.GoSlice)(unsafe.Pointer(&buf))).Ptr + pold := ((*rt.GoSlice)(unsafe.Pointer(&old))).Ptr + + /* return when allocated a new buffer */ + if pbuf != pold { + freeBytes(old) return buf, nil } /* make a copy of the result */ - ret := make([]byte, len(buf)) + ret = make([]byte, len(buf)) copy(ret, buf) freeBytes(buf) @@ -186,6 +197,15 @@ func Encode(val interface{}, opts Options) ([]byte, error) { // EncodeInto is like Encode but uses a user-supplied buffer instead of allocating // a new one. func EncodeInto(buf *[]byte, val interface{}, opts Options) error { + err := encodeInto(buf, val, opts) + if err != nil { + return err + } + *buf = encodeFinish(*buf, opts) + return err +} + +func encodeInto(buf *[]byte, val interface{}, opts Options) error { stk := newStack() efv := rt.UnpackEface(val) err := encodeTypedPointer(buf, efv.Type, &efv.Value, stk, uint64(opts)) @@ -196,25 +216,22 @@ func EncodeInto(buf *[]byte, val interface{}, opts Options) error { } freeStack(stk) - /* EscapeHTML needs to allocate a new buffer*/ - if opts & EscapeHTML != 0 { - dest := HTMLEscape(nil, *buf) - freeBytes(*buf) // free origin used buffer - *buf = dest - } - - if opts & ValidateString != 0 && !utf8.Validate(*buf) { - dest := utf8.CorrectWith(nil, *buf, `\ufffd`) - freeBytes(*buf) // free origin used buffer - *buf = dest - } - /* avoid GC ahead */ runtime.KeepAlive(buf) runtime.KeepAlive(efv) return err } +func encodeFinish(buf []byte, opts Options) []byte { + if opts & EscapeHTML != 0 { + buf = HTMLEscape(nil, buf) + } + if opts & ValidateString != 0 && !utf8.Validate(buf) { + buf = utf8.CorrectWith(nil, buf, `\ufffd`) + } + return buf +} + var typeByte = rt.UnpackType(reflect.TypeOf(byte(0))) // HTMLEscape appends to dst the JSON-encoded src with <, >, &, U+2028 and U+2029 diff --git a/vendor/github.com/bytedance/sonic/encoder/errors.go b/vendor/github.com/bytedance/sonic/internal/encoder/errors.go index ac6848a5b..ac6848a5b 100644 --- a/vendor/github.com/bytedance/sonic/encoder/errors.go +++ b/vendor/github.com/bytedance/sonic/internal/encoder/errors.go diff --git a/vendor/github.com/bytedance/sonic/encoder/mapiter.go b/vendor/github.com/bytedance/sonic/internal/encoder/mapiter.go index 8a322b3af..8a322b3af 100644 --- a/vendor/github.com/bytedance/sonic/encoder/mapiter.go +++ b/vendor/github.com/bytedance/sonic/internal/encoder/mapiter.go diff --git a/vendor/github.com/bytedance/sonic/encoder/pools.go b/vendor/github.com/bytedance/sonic/internal/encoder/pools.go index 600605d7c..9892ba11b 100644 --- a/vendor/github.com/bytedance/sonic/encoder/pools.go +++ b/vendor/github.com/bytedance/sonic/internal/encoder/pools.go @@ -30,7 +30,6 @@ import ( const ( _MaxStack = 4096 // 4k states - _MaxBuffer = 1048576 // 1MB buffer size _StackSize = unsafe.Sizeof(_Stack{}) ) @@ -92,7 +91,7 @@ func newBytes() []byte { if ret := bytesPool.Get(); ret != nil { return ret.([]byte) } else { - return make([]byte, 0, _MaxBuffer) + return make([]byte, 0, option.DefaultEncoderBufferSize) } } @@ -112,7 +111,7 @@ func newBuffer() *bytes.Buffer { if ret := bufferPool.Get(); ret != nil { return ret.(*bytes.Buffer) } else { - return bytes.NewBuffer(make([]byte, 0, _MaxBuffer)) + return bytes.NewBuffer(make([]byte, 0, option.DefaultEncoderBufferSize)) } } diff --git a/vendor/github.com/bytedance/sonic/encoder/primitives.go b/vendor/github.com/bytedance/sonic/internal/encoder/primitives.go index 78fb29ff6..78fb29ff6 100644 --- a/vendor/github.com/bytedance/sonic/encoder/primitives.go +++ b/vendor/github.com/bytedance/sonic/internal/encoder/primitives.go diff --git a/vendor/github.com/bytedance/sonic/encoder/sort.go b/vendor/github.com/bytedance/sonic/internal/encoder/sort.go index b1a67598b..b1a67598b 100644 --- a/vendor/github.com/bytedance/sonic/encoder/sort.go +++ b/vendor/github.com/bytedance/sonic/internal/encoder/sort.go diff --git a/vendor/github.com/bytedance/sonic/encoder/stream.go b/vendor/github.com/bytedance/sonic/internal/encoder/stream.go index 205232c71..8f73a2bf0 100644 --- a/vendor/github.com/bytedance/sonic/encoder/stream.go +++ b/vendor/github.com/bytedance/sonic/internal/encoder/stream.go @@ -21,7 +21,7 @@ import ( `io` ) -// StreamEncoder uses io.Writer as +// StreamEncoder uses io.Writer as input. type StreamEncoder struct { w io.Writer Encoder diff --git a/vendor/github.com/bytedance/sonic/encoder/stubs_go116.go b/vendor/github.com/bytedance/sonic/internal/encoder/stubs_go116.go index 40d06f4af..40d06f4af 100644 --- a/vendor/github.com/bytedance/sonic/encoder/stubs_go116.go +++ b/vendor/github.com/bytedance/sonic/internal/encoder/stubs_go116.go diff --git a/vendor/github.com/bytedance/sonic/encoder/stubs_go117.go b/vendor/github.com/bytedance/sonic/internal/encoder/stubs_go117.go index 6c8c6ec75..6c8c6ec75 100644 --- a/vendor/github.com/bytedance/sonic/encoder/stubs_go117.go +++ b/vendor/github.com/bytedance/sonic/internal/encoder/stubs_go117.go diff --git a/vendor/github.com/bytedance/sonic/encoder/stubs_go120.go b/vendor/github.com/bytedance/sonic/internal/encoder/stubs_go120.go index f1a7d10c7..f1a7d10c7 100644 --- a/vendor/github.com/bytedance/sonic/encoder/stubs_go120.go +++ b/vendor/github.com/bytedance/sonic/internal/encoder/stubs_go120.go diff --git a/vendor/github.com/bytedance/sonic/encoder/types.go b/vendor/github.com/bytedance/sonic/internal/encoder/types.go index 3d4a00668..3d4a00668 100644 --- a/vendor/github.com/bytedance/sonic/encoder/types.go +++ b/vendor/github.com/bytedance/sonic/internal/encoder/types.go diff --git a/vendor/github.com/bytedance/sonic/encoder/utils.go b/vendor/github.com/bytedance/sonic/internal/encoder/utils.go index 510596fda..510596fda 100644 --- a/vendor/github.com/bytedance/sonic/encoder/utils.go +++ b/vendor/github.com/bytedance/sonic/internal/encoder/utils.go diff --git a/vendor/github.com/bytedance/sonic/internal/jit/assembler_amd64.go b/vendor/github.com/bytedance/sonic/internal/jit/assembler_amd64.go index 00e6009db..d7d1751e5 100644 --- a/vendor/github.com/bytedance/sonic/internal/jit/assembler_amd64.go +++ b/vendor/github.com/bytedance/sonic/internal/jit/assembler_amd64.go @@ -72,6 +72,18 @@ func (self *BaseAssembler) NOPn(n int) { } } +func (self *BaseAssembler) StorePtr(ptr int64, to obj.Addr, tmp obj.Addr) { + if (to.Type != obj.TYPE_MEM) || (tmp.Type != obj.TYPE_REG) { + panic("must store imm to memory, tmp must be register") + } + if (ptr >> 32) != 0 { + self.Emit("MOVQ", Imm(ptr), tmp) + self.Emit("MOVQ", tmp, to) + } else { + self.Emit("MOVQ", Imm(ptr), to); + } +} + func (self *BaseAssembler) Byte(v ...byte) { for ; len(v) >= 8; v = v[8:] { self.From("QUAD", Imm(rt.Get64(v))) } for ; len(v) >= 4; v = v[4:] { self.From("LONG", Imm(int64(rt.Get32(v)))) } diff --git a/vendor/github.com/bytedance/sonic/internal/native/avx/native_amd64.go b/vendor/github.com/bytedance/sonic/internal/native/avx/native_amd64.go index 8a42449b8..d6a861068 100644 --- a/vendor/github.com/bytedance/sonic/internal/native/avx/native_amd64.go +++ b/vendor/github.com/bytedance/sonic/internal/native/avx/native_amd64.go @@ -122,7 +122,7 @@ func __validate_one(s *string, p *int, m *types.StateMachine) (ret int) //go:nosplit //go:noescape //goland:noinspection GoUnusedParameter -func __get_by_path(s *string, p *int, path *[]interface{}) (ret int) +func __get_by_path(s *string, p *int, path *[]interface{}, m *types.StateMachine) (ret int) //go:nosplit //go:noescape diff --git a/vendor/github.com/bytedance/sonic/internal/native/avx/native_amd64.s b/vendor/github.com/bytedance/sonic/internal/native/avx/native_amd64.s index 3b5304093..86eb36579 100644 --- a/vendor/github.com/bytedance/sonic/internal/native/avx/native_amd64.s +++ b/vendor/github.com/bytedance/sonic/internal/native/avx/native_amd64.s @@ -10,136 +10,52 @@ TEXT ·__native_entry__(SB), NOSPLIT, $0 LONG $0xf9058d48; WORD $0xffff; BYTE $0xff // leaq $-7(%rip), %rax LONG $0x24448948; BYTE $0x08 // movq %rax, $8(%rsp) BYTE $0xc3 // retq - WORD $0x0000; BYTE $0x00 // .p2align 4, 0x00 - -LCPI0_0: - QUAD $0x2020202020202020; QUAD $0x2020202020202020 // .space 16, ' ' - -LCPI0_1: - QUAD $0x0909090909090909; QUAD $0x0909090909090909 // .space 16, '\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t' - -LCPI0_2: - QUAD $0x0a0a0a0a0a0a0a0a; QUAD $0x0a0a0a0a0a0a0a0a // .space 16, '\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n' - -LCPI0_3: - QUAD $0x0d0d0d0d0d0d0d0d; QUAD $0x0d0d0d0d0d0d0d0d // .space 16, '\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r' + WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 - // .p2align 4, 0x90 _lspace: - BYTE $0x55 // pushq %rbp - WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp - WORD $0x8948; BYTE $0xd0 // movq %rdx, %rax - LONG $0x17148d4c // leaq (%rdi,%rdx), %r10 - WORD $0x8948; BYTE $0xf2 // movq %rsi, %rdx - WORD $0x2948; BYTE $0xc2 // subq %rax, %rdx - LONG $0x0066840f; WORD $0x0000 // je LBB0_7, $102(%rip) - WORD $0x8944; BYTE $0xd1 // movl %r10d, %ecx - WORD $0xe183; BYTE $0x0f // andl $15, %ecx - LONG $0x005a840f; WORD $0x0000 // je LBB0_7, $90(%rip) - LONG $0x014f8d4c // leaq $1(%rdi), %r9 - LONG $0xff4e8d48 // leaq $-1(%rsi), %rcx - QUAD $0x000100002600b849; WORD $0x0000 // movabsq $4294977024, %r8 - QUAD $0x9090909090909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x3948; BYTE $0xd6 // cmpq %rdx, %rsi + LONG $0x004e840f; WORD $0x0000 // je LBB0_1, $78(%rip) + LONG $0x37048d4c // leaq (%rdi,%rsi), %r8 + LONG $0x3a448d48; BYTE $0x01 // leaq $1(%rdx,%rdi), %rax + WORD $0x2948; BYTE $0xf2 // subq %rsi, %rdx + QUAD $0x000100002600be48; WORD $0x0000 // movabsq $4294977024, %rsi + QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 LBB0_3: - LONG $0x0714be0f // movsbl (%rdi,%rax), %edx - WORD $0xfa83; BYTE $0x20 // cmpl $32, %edx - LONG $0x00f0870f; WORD $0x0000 // ja LBB0_22, $240(%rip) - LONG $0xd0a30f49 // btq %rdx, %r8 - LONG $0x00e6830f; WORD $0x0000 // jae LBB0_22, $230(%rip) - LONG $0x01508d48 // leaq $1(%rax), %rdx - WORD $0x3948; BYTE $0xc1 // cmpq %rax, %rcx - LONG $0x000f840f; WORD $0x0000 // je LBB0_6, $15(%rip) - WORD $0x0144; BYTE $0xc8 // addl %r9d, %eax - WORD $0xe083; BYTE $0x0f // andl $15, %eax - WORD $0x8948; BYTE $0xd0 // movq %rdx, %rax - LONG $0xffcd850f; WORD $0xffff // jne LBB0_3, $-51(%rip) - -LBB0_6: - LONG $0x17148d4c // leaq (%rdi,%rdx), %r10 - WORD $0x2948; BYTE $0xd6 // subq %rdx, %rsi - WORD $0x8948; BYTE $0xf2 // movq %rsi, %rdx - -LBB0_7: - LONG $0x10fa8348 // cmpq $16, %rdx - LONG $0x006e820f; WORD $0x0000 // jb LBB0_13, $110(%rip) - WORD $0x8948; BYTE $0xfe // movq %rdi, %rsi - WORD $0x294c; BYTE $0xd6 // subq %r10, %rsi - QUAD $0xffffff2b056ff9c5 // vmovdqa $-213(%rip), %xmm0 /* LCPI0_0(%rip) */ - QUAD $0xffffff330d6ff9c5 // vmovdqa $-205(%rip), %xmm1 /* LCPI0_1(%rip) */ - QUAD $0xffffff3b156ff9c5 // vmovdqa $-197(%rip), %xmm2 /* LCPI0_2(%rip) */ - QUAD $0xffffff431d6ff9c5 // vmovdqa $-189(%rip), %xmm3 /* LCPI0_3(%rip) */ - WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 - -LBB0_9: - LONG $0x6f79c1c4; BYTE $0x22 // vmovdqa (%r10), %xmm4 - LONG $0xe874d9c5 // vpcmpeqb %xmm0, %xmm4, %xmm5 - LONG $0xf174d9c5 // vpcmpeqb %xmm1, %xmm4, %xmm6 - LONG $0xeeebd1c5 // vpor %xmm6, %xmm5, %xmm5 - LONG $0xf274d9c5 // vpcmpeqb %xmm2, %xmm4, %xmm6 - LONG $0xe374d9c5 // vpcmpeqb %xmm3, %xmm4, %xmm4 - LONG $0xe6ebd9c5 // vpor %xmm6, %xmm4, %xmm4 - LONG $0xe5ebd9c5 // vpor %xmm5, %xmm4, %xmm4 - LONG $0xc4d7f9c5 // vpmovmskb %xmm4, %eax - LONG $0xfff88366 // cmpw $-1, %ax - LONG $0x0060850f; WORD $0x0000 // jne LBB0_10, $96(%rip) - LONG $0x10c28349 // addq $16, %r10 - LONG $0xf0c28348 // addq $-16, %rdx - LONG $0xf0c68348 // addq $-16, %rsi - LONG $0x0ffa8348 // cmpq $15, %rdx - LONG $0xffbb870f; WORD $0xffff // ja LBB0_9, $-69(%rip) - -LBB0_13: - WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx - LONG $0x0039840f; WORD $0x0000 // je LBB0_20, $57(%rip) - LONG $0x12048d4d // leaq (%r10,%rdx), %r8 - WORD $0xc031 // xorl %eax, %eax - QUAD $0x000100002600b949; WORD $0x0000 // movabsq $4294977024, %r9 - WORD $0x9090 // .p2align 4, 0x90 - -LBB0_15: - LONG $0x34be0f41; BYTE $0x02 // movsbl (%r10,%rax), %esi - WORD $0xfe83; BYTE $0x20 // cmpl $32, %esi - LONG $0x002e870f; WORD $0x0000 // ja LBB0_17, $46(%rip) - LONG $0xf1a30f49 // btq %rsi, %r9 - LONG $0x0024830f; WORD $0x0000 // jae LBB0_17, $36(%rip) + LONG $0xff48be0f // movsbl $-1(%rax), %ecx + WORD $0xf983; BYTE $0x20 // cmpl $32, %ecx + LONG $0x002c870f; WORD $0x0000 // ja LBB0_5, $44(%rip) + LONG $0xcea30f48 // btq %rcx, %rsi + LONG $0x0022830f; WORD $0x0000 // jae LBB0_5, $34(%rip) WORD $0xff48; BYTE $0xc0 // incq %rax - WORD $0x3948; BYTE $0xc2 // cmpq %rax, %rdx - LONG $0xffdc850f; WORD $0xffff // jne LBB0_15, $-36(%rip) - WORD $0x894d; BYTE $0xc2 // movq %r8, %r10 - -LBB0_20: - WORD $0x2949; BYTE $0xfa // subq %rdi, %r10 - -LBB0_21: - WORD $0x894c; BYTE $0xd0 // movq %r10, %rax - -LBB0_22: - BYTE $0x5d // popq %rbp - BYTE $0xc3 // retq + WORD $0xff48; BYTE $0xc2 // incq %rdx + LONG $0xffdd850f; WORD $0xffff // jne LBB0_3, $-35(%rip) + WORD $0x2949; BYTE $0xf8 // subq %rdi, %r8 + WORD $0x894c; BYTE $0xc0 // movq %r8, %rax + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq -LBB0_10: - WORD $0xb70f; BYTE $0xc0 // movzwl %ax, %eax - WORD $0xd0f7 // notl %eax - WORD $0xbc0f; BYTE $0xc0 // bsfl %eax, %eax - WORD $0x2948; BYTE $0xf0 // subq %rsi, %rax +LBB0_1: + WORD $0x0148; BYTE $0xfa // addq %rdi, %rdx + WORD $0x8949; BYTE $0xd0 // movq %rdx, %r8 + WORD $0x2949; BYTE $0xf8 // subq %rdi, %r8 + WORD $0x894c; BYTE $0xc0 // movq %r8, %rax BYTE $0x5d // popq %rbp BYTE $0xc3 // retq -LBB0_17: - WORD $0x2949; BYTE $0xfa // subq %rdi, %r10 - WORD $0x0149; BYTE $0xc2 // addq %rax, %r10 - LONG $0xffffe3e9; BYTE $0xff // jmp LBB0_21, $-29(%rip) - QUAD $0x0000000000000000; QUAD $0x0000000000000000; QUAD $0x0000000000000000; BYTE $0x00 // .p2align 5, 0x00 +LBB0_5: + WORD $0xf748; BYTE $0xd7 // notq %rdi + WORD $0x0148; BYTE $0xf8 // addq %rdi, %rax + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + QUAD $0x0000000000000000; QUAD $0x0000000000000000; QUAD $0x0000000000000000; LONG $0x00000000; WORD $0x0000; BYTE $0x00 // .p2align 5, 0x00 LCPI1_0: QUAD $0x3030303030303030; QUAD $0x3030303030303030 // .space 16, '0000000000000000' QUAD $0x3030303030303030; QUAD $0x3030303030303030 // .space 16, '0000000000000000' - // .p2align 4, 0x00 -LCPI1_1: - QUAD $0x3030303030303030; QUAD $0x3030303030303030 // .space 16, '0000000000000000' - // .p2align 4, 0x90 _f64toa: BYTE $0x55 // pushq %rbp @@ -155,271 +71,264 @@ _f64toa: LONG $0x34e8c148 // shrq $52, %rax LONG $0x0007ff25; BYTE $0x00 // andl $2047, %eax LONG $0x0007ff3d; BYTE $0x00 // cmpl $2047, %eax - LONG $0x0c1e840f; WORD $0x0000 // je LBB1_1, $3102(%rip) - WORD $0x8948; BYTE $0xfe // movq %rdi, %rsi + LONG $0x0ade840f; WORD $0x0000 // je LBB1_1, $2782(%rip) + WORD $0x8949; BYTE $0xfe // movq %rdi, %r14 WORD $0x07c6; BYTE $0x2d // movb $45, (%rdi) - WORD $0x8949; BYTE $0xd5 // movq %rdx, %r13 - LONG $0x3fedc149 // shrq $63, %r13 - LONG $0x2f3c8d4e // leaq (%rdi,%r13), %r15 + WORD $0x8949; BYTE $0xd4 // movq %rdx, %r12 + LONG $0x3fecc149 // shrq $63, %r12 + LONG $0x273c8d4e // leaq (%rdi,%r12), %r15 QUAD $0x00000000550c8d48 // leaq (,%rdx,2), %rcx WORD $0x8548; BYTE $0xc9 // testq %rcx, %rcx - LONG $0x01f5840f; WORD $0x0000 // je LBB1_3, $501(%rip) + LONG $0x01e3840f; WORD $0x0000 // je LBB1_3, $483(%rip) QUAD $0xffffffffffffbf48; WORD $0x000f // movabsq $4503599627370495, %rdi WORD $0x2148; BYTE $0xfa // andq %rdi, %rdx WORD $0xc085 // testl %eax, %eax - LONG $0xd0758948 // movq %rsi, $-48(%rbp) - LONG $0x0bea840f; WORD $0x0000 // je LBB1_5, $3050(%rip) + LONG $0x0aae840f; WORD $0x0000 // je LBB1_5, $2734(%rip) WORD $0xff48; BYTE $0xc7 // incq %rdi WORD $0x0948; BYTE $0xd7 // orq %rdx, %rdi - LONG $0xfbcdb08d; WORD $0xffff // leal $-1075(%rax), %esi + LONG $0xfbcd988d; WORD $0xffff // leal $-1075(%rax), %ebx LONG $0xfc01888d; WORD $0xffff // leal $-1023(%rax), %ecx WORD $0xf983; BYTE $0x34 // cmpl $52, %ecx - LONG $0x001d870f; WORD $0x0000 // ja LBB1_6, $29(%rip) - LONG $0x000433b9; BYTE $0x00 // movl $1075, %ecx - WORD $0xc129 // subl %eax, %ecx - LONG $0xffc3c748; WORD $0xffff; BYTE $0xff // movq $-1, %rbx - WORD $0xd348; BYTE $0xe3 // shlq %cl, %rbx - WORD $0xf748; BYTE $0xd3 // notq %rbx - WORD $0x8548; BYTE $0xdf // testq %rbx, %rdi + LONG $0x001a870f; WORD $0x0000 // ja LBB1_6, $26(%rip) + WORD $0xd989 // movl %ebx, %ecx + WORD $0xd9f7 // negl %ecx + LONG $0xffc6c748; WORD $0xffff; BYTE $0xff // movq $-1, %rsi + WORD $0xd348; BYTE $0xe6 // shlq %cl, %rsi + WORD $0xf748; BYTE $0xd6 // notq %rsi + WORD $0x8548; BYTE $0xf7 // testq %rsi, %rdi LONG $0x0421840f; WORD $0x0000 // je LBB1_11, $1057(%rip) LBB1_6: WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx WORD $0x940f; BYTE $0xc1 // sete %cl - WORD $0xf883; BYTE $0x02 // cmpl $2, %eax - WORD $0x930f; BYTE $0xc0 // setae %al + WORD $0xf883; BYTE $0x01 // cmpl $1, %eax + WORD $0x970f; BYTE $0xc0 // seta %al WORD $0xc820 // andb %cl, %al - QUAD $0x00000000bd0c8d4c // leaq (,%rdi,4), %r9 WORD $0xb60f; BYTE $0xc0 // movzbl %al, %eax - LONG $0xb81c8d48 // leaq (%rax,%rdi,4), %rbx - LONG $0xfec38348 // addq $-2, %rbx - LONG $0x4413ce69; WORD $0x0013 // imull $1262611, %esi, %ecx - LONG $0x01918d44; WORD $0xf801; BYTE $0xff // leal $-524031(%rcx), %r10d + LONG $0x4413cb69; WORD $0x0013 // imull $1262611, %ebx, %ecx + WORD $0xd231 // xorl %edx, %edx WORD $0xc084 // testb %al, %al - LONG $0xd1440f44 // cmovel %ecx, %r10d - QUAD $0x00000002bd048d4c // leaq $2(,%rdi,4), %r8 - LONG $0x16fac141 // sarl $22, %r10d - LONG $0xb1ca6941; WORD $0xe56c; BYTE $0xff // imull $-1741647, %r10d, %ecx + LONG $0x0101b941; WORD $0xfff8 // movl $-524031, %r9d + LONG $0xca440f44 // cmovel %edx, %r9d + LONG $0xb8748d48; BYTE $0xfe // leaq $-2(%rax,%rdi,4), %rsi + WORD $0x0141; BYTE $0xc9 // addl %ecx, %r9d + LONG $0x16f9c141 // sarl $22, %r9d + LONG $0xb1c96941; WORD $0xe56c; BYTE $0xff // imull $-1741647, %r9d, %ecx WORD $0xe9c1; BYTE $0x13 // shrl $19, %ecx - WORD $0xf101 // addl %esi, %ecx + WORD $0xd901 // addl %ebx, %ecx LONG $0x000124b8; BYTE $0x00 // movl $292, %eax - WORD $0x2944; BYTE $0xd0 // subl %r10d, %eax + WORD $0x2944; BYTE $0xc8 // subl %r9d, %eax LONG $0x04e0c148 // shlq $4, %rax - LONG $0x34158d48; WORD $0x00b8; BYTE $0x00 // leaq $47156(%rip), %rdx /* _pow10_ceil_sig.g(%rip) */ + LONG $0x3a158d48; WORD $0x00bb; BYTE $0x00 // leaq $47930(%rip), %rdx /* _pow10_ceil_sig.g(%rip) */ LONG $0x101c8b4c // movq (%rax,%rdx), %r11 - LONG $0x10748b4c; BYTE $0x08 // movq $8(%rax,%rdx), %r14 + LONG $0x106c8b4c; BYTE $0x08 // movq $8(%rax,%rdx), %r13 WORD $0xc1fe // incb %cl - WORD $0xd348; BYTE $0xe3 // shlq %cl, %rbx - WORD $0x8948; BYTE $0xd8 // movq %rbx, %rax - WORD $0xf749; BYTE $0xe6 // mulq %r14 - WORD $0x8948; BYTE $0xd6 // movq %rdx, %rsi - WORD $0x8948; BYTE $0xd8 // movq %rbx, %rax - WORD $0xf749; BYTE $0xe3 // mulq %r11 - WORD $0x0148; BYTE $0xf0 // addq %rsi, %rax - LONG $0x00d28348 // adcq $0, %rdx - WORD $0xf631 // xorl %esi, %esi - LONG $0xfffea948; WORD $0xffff // testq $-2, %rax - LONG $0xc6950f40 // setne %sil - WORD $0x0948; BYTE $0xd6 // orq %rdx, %rsi - WORD $0xd349; BYTE $0xe1 // shlq %cl, %r9 - WORD $0x894c; BYTE $0xc8 // movq %r9, %rax - WORD $0xf749; BYTE $0xe6 // mulq %r14 + WORD $0xd348; BYTE $0xe6 // shlq %cl, %rsi + WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax + WORD $0xf749; BYTE $0xe5 // mulq %r13 WORD $0x8948; BYTE $0xd3 // movq %rdx, %rbx - WORD $0x894c; BYTE $0xc8 // movq %r9, %rax + WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax WORD $0xf749; BYTE $0xe3 // mulq %r11 - WORD $0x8949; BYTE $0xd1 // movq %rdx, %r9 + QUAD $0x00000000bd348d48 // leaq (,%rdi,4), %rsi WORD $0x0148; BYTE $0xd8 // addq %rbx, %rax - LONG $0x00d18349 // adcq $0, %r9 + LONG $0x00d28348 // adcq $0, %rdx WORD $0xdb31 // xorl %ebx, %ebx - LONG $0xfffea948; WORD $0xffff // testq $-2, %rax - WORD $0x950f; BYTE $0xc3 // setne %bl - WORD $0x094c; BYTE $0xcb // orq %r9, %rbx - WORD $0xd349; BYTE $0xe0 // shlq %cl, %r8 - WORD $0x894c; BYTE $0xc0 // movq %r8, %rax - WORD $0xf749; BYTE $0xe6 // mulq %r14 + LONG $0x01f88348 // cmpq $1, %rax + WORD $0x970f; BYTE $0xc3 // seta %bl + WORD $0x0948; BYTE $0xd3 // orq %rdx, %rbx + WORD $0xd348; BYTE $0xe6 // shlq %cl, %rsi + WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax + WORD $0xf749; BYTE $0xe5 // mulq %r13 + WORD $0x8949; BYTE $0xd2 // movq %rdx, %r10 + WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax + WORD $0xf749; BYTE $0xe3 // mulq %r11 + WORD $0x8949; BYTE $0xd0 // movq %rdx, %r8 + QUAD $0x00000002bd348d48 // leaq $2(,%rdi,4), %rsi + WORD $0x014c; BYTE $0xd0 // addq %r10, %rax + LONG $0x00d08349 // adcq $0, %r8 + WORD $0x3145; BYTE $0xd2 // xorl %r10d, %r10d + LONG $0x01f88348 // cmpq $1, %rax + LONG $0xc2970f41 // seta %r10b + WORD $0x094d; BYTE $0xc2 // orq %r8, %r10 + WORD $0xd348; BYTE $0xe6 // shlq %cl, %rsi + WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax + WORD $0xf749; BYTE $0xe5 // mulq %r13 WORD $0x8948; BYTE $0xd1 // movq %rdx, %rcx - WORD $0x894c; BYTE $0xc0 // movq %r8, %rax + WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax WORD $0xf749; BYTE $0xe3 // mulq %r11 WORD $0x0148; BYTE $0xc8 // addq %rcx, %rax LONG $0x00d28348 // adcq $0, %rdx WORD $0xc931 // xorl %ecx, %ecx - LONG $0xfffea948; WORD $0xffff // testq $-2, %rax - WORD $0x950f; BYTE $0xc1 // setne %cl + LONG $0x01f88348 // cmpq $1, %rax + WORD $0x970f; BYTE $0xc1 // seta %cl WORD $0x0948; BYTE $0xd1 // orq %rdx, %rcx WORD $0xe783; BYTE $0x01 // andl $1, %edi - WORD $0x0148; BYTE $0xfe // addq %rdi, %rsi + WORD $0x0148; BYTE $0xfb // addq %rdi, %rbx WORD $0x2948; BYTE $0xf9 // subq %rdi, %rcx - LONG $0x28fb8348 // cmpq $40, %rbx - LONG $0x0043820f; WORD $0x0000 // jb LBB1_28, $67(%rip) + LONG $0x28fa8349 // cmpq $40, %r10 + LONG $0x003e820f; WORD $0x0000 // jb LBB1_29, $62(%rip) QUAD $0xcccccccccccdba48; WORD $0xcccc // movabsq $-3689348814741910323, %rdx - WORD $0x894c; BYTE $0xc8 // movq %r9, %rax + WORD $0x894c; BYTE $0xc0 // movq %r8, %rax WORD $0xf748; BYTE $0xe2 // mulq %rdx WORD $0x8948; BYTE $0xd7 // movq %rdx, %rdi LONG $0x05efc148 // shrq $5, %rdi QUAD $0x00000000fd048d48 // leaq (,%rdi,8), %rax LONG $0x80148d48 // leaq (%rax,%rax,4), %rdx - WORD $0x3948; BYTE $0xd6 // cmpq %rdx, %rsi - LONG $0xc0970f41 // seta %r8b - LONG $0x80148d48 // leaq (%rax,%rax,4), %rdx - LONG $0x28c28348 // addq $40, %rdx - WORD $0xc031 // xorl %eax, %eax - WORD $0x3948; BYTE $0xca // cmpq %rcx, %rdx + WORD $0x3948; BYTE $0xd3 // cmpq %rdx, %rbx + LONG $0xc6970f40 // seta %sil + LONG $0x80448d48; BYTE $0x28 // leaq $40(%rax,%rax,4), %rax + WORD $0x3948; BYTE $0xc8 // cmpq %rcx, %rax WORD $0x960f; BYTE $0xc2 // setbe %dl - WORD $0x3841; BYTE $0xd0 // cmpb %dl, %r8b - LONG $0x0134840f; WORD $0x0000 // je LBB1_8, $308(%rip) + WORD $0x3040; BYTE $0xf2 // xorb %sil, %dl + LONG $0x0130840f; WORD $0x0000 // je LBB1_8, $304(%rip) -LBB1_28: - WORD $0x894d; BYTE $0xc8 // movq %r9, %r8 - LONG $0x02e8c149 // shrq $2, %r8 - WORD $0x894c; BYTE $0xca // movq %r9, %rdx +LBB1_29: + WORD $0x894c; BYTE $0xc0 // movq %r8, %rax + LONG $0x02e8c148 // shrq $2, %rax + WORD $0x894c; BYTE $0xc2 // movq %r8, %rdx LONG $0xfce28348 // andq $-4, %rdx - WORD $0x3948; BYTE $0xd6 // cmpq %rdx, %rsi + WORD $0x3948; BYTE $0xd3 // cmpq %rdx, %rbx LONG $0xc7970f40 // seta %dil LONG $0x04728d48 // leaq $4(%rdx), %rsi WORD $0x3948; BYTE $0xce // cmpq %rcx, %rsi - WORD $0x960f; BYTE $0xc0 // setbe %al - WORD $0x3040; BYTE $0xf8 // xorb %dil, %al - LONG $0x0055840f; WORD $0x0000 // je LBB1_29, $85(%rip) + WORD $0x960f; BYTE $0xc3 // setbe %bl + WORD $0x3040; BYTE $0xfb // xorb %dil, %bl + LONG $0x0053840f; WORD $0x0000 // je LBB1_30, $83(%rip) LONG $0x02ca8348 // orq $2, %rdx LONG $0x000001bf; BYTE $0x00 // movl $1, %edi - WORD $0x3948; BYTE $0xd3 // cmpq %rdx, %rbx - LONG $0x000e870f; WORD $0x0000 // ja LBB1_32, $14(%rip) - WORD $0x940f; BYTE $0xc0 // sete %al - LONG $0x02e9c041 // shrb $2, %r9b - WORD $0x2041; BYTE $0xc1 // andb %al, %r9b - LONG $0xf9b60f41 // movzbl %r9b, %edi - -LBB1_32: - WORD $0x014c; BYTE $0xc7 // addq %r8, %rdi - QUAD $0x0001ffffff80bc49; WORD $0x0000 // movabsq $8589934464, %r12 - QUAD $0x540be47f24848d49 // leaq $1410065535(%r12), %rax + WORD $0x3949; BYTE $0xd2 // cmpq %rdx, %r10 + LONG $0x000e870f; WORD $0x0000 // ja LBB1_33, $14(%rip) + WORD $0x940f; BYTE $0xc1 // sete %cl + LONG $0x02e8c041 // shrb $2, %r8b + WORD $0x2041; BYTE $0xc8 // andb %cl, %r8b + LONG $0xf8b60f41 // movzbl %r8b, %edi + +LBB1_33: + WORD $0x0148; BYTE $0xc7 // addq %rax, %rdi + QUAD $0x0001ffffff80b848; WORD $0x0000 // movabsq $8589934464, %rax + LONG $0xe47f0548; WORD $0x540b // addq $1410065535, %rax WORD $0x3948; BYTE $0xc7 // cmpq %rax, %rdi - LONG $0x003c870f; WORD $0x0000 // ja LBB1_34, $60(%rip) - LONG $0x0000ece9; BYTE $0x00 // jmp LBB1_40, $236(%rip) + LONG $0x003a870f; WORD $0x0000 // ja LBB1_35, $58(%rip) + LONG $0x0000eae9; BYTE $0x00 // jmp LBB1_41, $234(%rip) LBB1_3: LONG $0x3007c641 // movb $48, (%r15) - WORD $0x2941; BYTE $0xf7 // subl %esi, %r15d + WORD $0x2945; BYTE $0xf7 // subl %r14d, %r15d WORD $0xff41; BYTE $0xc7 // incl %r15d WORD $0x8944; BYTE $0xfb // movl %r15d, %ebx - LONG $0x0009e1e9; BYTE $0x00 // jmp LBB1_123, $2529(%rip) + LONG $0x0008a2e9; BYTE $0x00 // jmp LBB1_116, $2210(%rip) -LBB1_29: +LBB1_30: WORD $0x3948; BYTE $0xf1 // cmpq %rsi, %rcx - LONG $0xffd88349 // sbbq $-1, %r8 - WORD $0x894c; BYTE $0xc7 // movq %r8, %rdi - QUAD $0x0001ffffff80bc49; WORD $0x0000 // movabsq $8589934464, %r12 - QUAD $0x540be47f24848d49 // leaq $1410065535(%r12), %rax + LONG $0xffd88348 // sbbq $-1, %rax + WORD $0x8948; BYTE $0xc7 // movq %rax, %rdi + QUAD $0x0001ffffff80b848; WORD $0x0000 // movabsq $8589934464, %rax + LONG $0xe47f0548; WORD $0x540b // addq $1410065535, %rax WORD $0x3948; BYTE $0xc7 // cmpq %rax, %rdi - LONG $0x00b5860f; WORD $0x0000 // jbe LBB1_40, $181(%rip) + LONG $0x00b5860f; WORD $0x0000 // jbe LBB1_41, $181(%rip) -LBB1_34: +LBB1_35: WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax LONG $0x0be8c148 // shrq $11, %rax LONG $0x00000bba; BYTE $0x00 // movl $11, %edx LONG $0x0edd3d48; WORD $0x02e9 // cmpq $48828125, %rax - LONG $0x0136820f; WORD $0x0000 // jb LBB1_49, $310(%rip) + LONG $0x0127820f; WORD $0x0000 // jb LBB1_51, $295(%rip) WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax LONG $0x0ce8c148 // shrq $12, %rax LONG $0x00000cba; BYTE $0x00 // movl $12, %edx LONG $0x4a513d48; WORD $0x0e8d // cmpq $244140625, %rax - LONG $0x011e820f; WORD $0x0000 // jb LBB1_49, $286(%rip) + LONG $0x010f820f; WORD $0x0000 // jb LBB1_51, $271(%rip) WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax LONG $0x0de8c148 // shrq $13, %rax LONG $0x00000dba; BYTE $0x00 // movl $13, %edx LONG $0x73953d48; WORD $0x48c2 // cmpq $1220703125, %rax - LONG $0x0106820f; WORD $0x0000 // jb LBB1_49, $262(%rip) + LONG $0x00f7820f; WORD $0x0000 // jb LBB1_51, $247(%rip) LONG $0x00000eba; BYTE $0x00 // movl $14, %edx QUAD $0x5af3107a4000b848; WORD $0x0000 // movabsq $100000000000000, %rax WORD $0x3948; BYTE $0xc7 // cmpq %rax, %rdi - LONG $0x00ee820f; WORD $0x0000 // jb LBB1_49, $238(%rip) + LONG $0x00df820f; WORD $0x0000 // jb LBB1_51, $223(%rip) LONG $0x00000fba; BYTE $0x00 // movl $15, %edx QUAD $0x8d7ea4c68000b848; WORD $0x0003 // movabsq $1000000000000000, %rax WORD $0x3948; BYTE $0xc7 // cmpq %rax, %rdi - LONG $0x00d6820f; WORD $0x0000 // jb LBB1_49, $214(%rip) + LONG $0x00c7820f; WORD $0x0000 // jb LBB1_51, $199(%rip) QUAD $0x86f26fc10000b848; WORD $0x0023 // movabsq $10000000000000000, %rax - WORD $0xd231 // xorl %edx, %edx WORD $0x3948; BYTE $0xc7 // cmpq %rax, %rdi - WORD $0x920f; BYTE $0xc2 // setb %dl - WORD $0xf283; BYTE $0x11 // xorl $17, %edx - LONG $0x0000bce9; BYTE $0x00 // jmp LBB1_49, $188(%rip) + LONG $0x000011ba; BYTE $0x00 // movl $17, %edx + +LBB1_50: + WORD $0xda83; BYTE $0x00 // sbbl $0, %edx + LONG $0x0000ade9; BYTE $0x00 // jmp LBB1_51, $173(%rip) LBB1_8: - WORD $0xd088 // movb %dl, %al - WORD $0x0148; BYTE $0xc7 // addq %rax, %rdi - WORD $0xff41; BYTE $0xc2 // incl %r10d - QUAD $0x0001ffffff80bc49; WORD $0x0000 // movabsq $8589934464, %r12 - QUAD $0x540be47f24848d49 // leaq $1410065535(%r12), %rax + WORD $0x3948; BYTE $0xc1 // cmpq %rax, %rcx + LONG $0xffdf8348 // sbbq $-1, %rdi + WORD $0xff41; BYTE $0xc1 // incl %r9d + QUAD $0x0001ffffff80b848; WORD $0x0000 // movabsq $8589934464, %rax + LONG $0xe47f0548; WORD $0x540b // addq $1410065535, %rax WORD $0x3948; BYTE $0xc7 // cmpq %rax, %rdi - LONG $0xff4b870f; WORD $0xffff // ja LBB1_34, $-181(%rip) + LONG $0xff4b870f; WORD $0xffff // ja LBB1_35, $-181(%rip) -LBB1_40: +LBB1_41: LONG $0x000001ba; BYTE $0x00 // movl $1, %edx LONG $0x0aff8348 // cmpq $10, %rdi - LONG $0x008a820f; WORD $0x0000 // jb LBB1_49, $138(%rip) + LONG $0x007b820f; WORD $0x0000 // jb LBB1_51, $123(%rip) LONG $0x000002ba; BYTE $0x00 // movl $2, %edx LONG $0x64ff8348 // cmpq $100, %rdi - LONG $0x007b820f; WORD $0x0000 // jb LBB1_49, $123(%rip) + LONG $0x006c820f; WORD $0x0000 // jb LBB1_51, $108(%rip) LONG $0x000003ba; BYTE $0x00 // movl $3, %edx LONG $0xe8ff8148; WORD $0x0003; BYTE $0x00 // cmpq $1000, %rdi - LONG $0x0069820f; WORD $0x0000 // jb LBB1_49, $105(%rip) + LONG $0x005a820f; WORD $0x0000 // jb LBB1_51, $90(%rip) LONG $0x000004ba; BYTE $0x00 // movl $4, %edx LONG $0x10ff8148; WORD $0x0027; BYTE $0x00 // cmpq $10000, %rdi - LONG $0x0057820f; WORD $0x0000 // jb LBB1_49, $87(%rip) + LONG $0x0048820f; WORD $0x0000 // jb LBB1_51, $72(%rip) LONG $0x000005ba; BYTE $0x00 // movl $5, %edx LONG $0xa0ff8148; WORD $0x0186; BYTE $0x00 // cmpq $100000, %rdi - LONG $0x0045820f; WORD $0x0000 // jb LBB1_49, $69(%rip) + LONG $0x0036820f; WORD $0x0000 // jb LBB1_51, $54(%rip) LONG $0x000006ba; BYTE $0x00 // movl $6, %edx LONG $0x40ff8148; WORD $0x0f42; BYTE $0x00 // cmpq $1000000, %rdi - LONG $0x0033820f; WORD $0x0000 // jb LBB1_49, $51(%rip) + LONG $0x0024820f; WORD $0x0000 // jb LBB1_51, $36(%rip) LONG $0x000007ba; BYTE $0x00 // movl $7, %edx LONG $0x80ff8148; WORD $0x9896; BYTE $0x00 // cmpq $10000000, %rdi - LONG $0x0021820f; WORD $0x0000 // jb LBB1_49, $33(%rip) + LONG $0x0012820f; WORD $0x0000 // jb LBB1_51, $18(%rip) LONG $0x000008ba; BYTE $0x00 // movl $8, %edx LONG $0x00ff8148; WORD $0xf5e1; BYTE $0x05 // cmpq $100000000, %rdi - LONG $0x000f820f; WORD $0x0000 // jb LBB1_49, $15(%rip) - LONG $0x00ff8148; WORD $0x9aca; BYTE $0x3b // cmpq $1000000000, %rdi - LONG $0x00000aba; BYTE $0x00 // movl $10, %edx - WORD $0xda83; BYTE $0x00 // sbbl $0, %edx - -LBB1_49: - LONG $0x12348d46 // leal (%rdx,%r10), %r14d - LONG $0x12048d42 // leal (%rdx,%r10), %eax - WORD $0xc083; BYTE $0xea // addl $-22, %eax - WORD $0xf883; BYTE $0xe4 // cmpl $-28, %eax - LONG $0x00a4870f; WORD $0x0000 // ja LBB1_62, $164(%rip) - LONG $0x01678d4d // leaq $1(%r15), %r12 - WORD $0x894c; BYTE $0xe6 // movq %r12, %rsi - LONG $0x007c8ae8; BYTE $0x00 // callq _format_significand, $31882(%rip) - WORD $0x8948; BYTE $0xc3 // movq %rax, %rbx - LONG $0xd0558b4c // movq $-48(%rbp), %r10 - WORD $0x294c; BYTE $0xd0 // subq %r10, %rax - WORD $0x294c; BYTE $0xe8 // subq %r13, %rax - QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 + LONG $0x0754830f; WORD $0x0000 // jae LBB1_49, $1876(%rip) LBB1_51: - WORD $0xff48; BYTE $0xc8 // decq %rax + LONG $0x0a2c8d46 // leal (%rdx,%r9), %r13d + LONG $0x0a448d42; BYTE $0x05 // leal $5(%rdx,%r9), %eax + WORD $0xf883; BYTE $0x1b // cmpl $27, %eax + LONG $0x009d820f; WORD $0x0000 // jb LBB1_64, $157(%rip) + LONG $0x01678d4d // leaq $1(%r15), %r12 + WORD $0x894c; BYTE $0xe6 // movq %r12, %rsi + LONG $0x0082cfe8; BYTE $0x00 // callq _format_significand, $33487(%rip) + WORD $0x8948; BYTE $0xc3 // movq %rax, %rbx + QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90 + +LBB1_53: LONG $0x30ff7b80 // cmpb $48, $-1(%rbx) LONG $0xff5b8d48 // leaq $-1(%rbx), %rbx - LONG $0xffef840f; WORD $0xffff // je LBB1_51, $-17(%rip) - LONG $0x4fb60f41; BYTE $0x01 // movzbl $1(%r15), %ecx - WORD $0x8841; BYTE $0x0f // movb %cl, (%r15) - LONG $0x02f88348 // cmpq $2, %rax - LONG $0x00088c0f; WORD $0x0000 // jl LBB1_54, $8(%rip) - WORD $0xff48; BYTE $0xc3 // incq %rbx + LONG $0xfff2840f; WORD $0xffff // je LBB1_53, $-14(%rip) + LONG $0x01478a41 // movb $1(%r15), %al + WORD $0x8841; BYTE $0x07 // movb %al, (%r15) + LONG $0x01438d48 // leaq $1(%rbx), %rax + WORD $0x8948; BYTE $0xc1 // movq %rax, %rcx + WORD $0x294c; BYTE $0xe1 // subq %r12, %rcx + LONG $0x02f98348 // cmpq $2, %rcx + LONG $0x00088c0f; WORD $0x0000 // jl LBB1_56, $8(%rip) LONG $0x2404c641; BYTE $0x2e // movb $46, (%r12) + WORD $0x8948; BYTE $0xc3 // movq %rax, %rbx -LBB1_54: +LBB1_56: WORD $0x03c6; BYTE $0x65 // movb $101, (%rbx) - WORD $0x8545; BYTE $0xf6 // testl %r14d, %r14d - LONG $0x011d8e0f; WORD $0x0000 // jle LBB1_55, $285(%rip) - WORD $0xff41; BYTE $0xce // decl %r14d + LONG $0xff458d41 // leal $-1(%r13), %eax + WORD $0x8545; BYTE $0xed // testl %r13d, %r13d + LONG $0x01548e0f; WORD $0x0000 // jle LBB1_57, $340(%rip) LONG $0x2b0143c6 // movb $43, $1(%rbx) - WORD $0x8944; BYTE $0xf0 // movl %r14d, %eax WORD $0xf883; BYTE $0x64 // cmpl $100, %eax - LONG $0x011f820f; WORD $0x0000 // jb LBB1_59, $287(%rip) + LONG $0x01568c0f; WORD $0x0000 // jl LBB1_61, $342(%rip) -LBB1_58: +LBB1_60: WORD $0xc189 // movl %eax, %ecx LONG $0xcccccdba; BYTE $0xcc // movl $3435973837, %edx LONG $0xd1af0f48 // imulq %rcx, %rdx @@ -427,100 +336,111 @@ LBB1_58: WORD $0x0c8d; BYTE $0x12 // leal (%rdx,%rdx), %ecx WORD $0x0c8d; BYTE $0x89 // leal (%rcx,%rcx,4), %ecx WORD $0xc829 // subl %ecx, %eax - LONG $0xf80d8d48; WORD $0x00b3; BYTE $0x00 // leaq $46072(%rip), %rcx /* _Digits(%rip) */ + LONG $0x140d8d48; WORD $0x00b7; BYTE $0x00 // leaq $46868(%rip), %rcx /* _Digits(%rip) */ LONG $0x510cb70f // movzwl (%rcx,%rdx,2), %ecx LONG $0x024b8966 // movw %cx, $2(%rbx) WORD $0x300c // orb $48, %al WORD $0x4388; BYTE $0x04 // movb %al, $4(%rbx) LONG $0x05c38348 // addq $5, %rbx - LONG $0x0007b3e9; BYTE $0x00 // jmp LBB1_122, $1971(%rip) + LONG $0x00068ee9; BYTE $0x00 // jmp LBB1_115, $1678(%rip) -LBB1_62: - WORD $0x8545; BYTE $0xd2 // testl %r10d, %r10d - LONG $0x0105880f; WORD $0x0000 // js LBB1_63, $261(%rip) - WORD $0x8945; BYTE $0xf6 // movl %r14d, %r14d - LONG $0x371c8d4b // leaq (%r15,%r14), %rbx - WORD $0x894c; BYTE $0xfe // movq %r15, %rsi - LONG $0x0007dae8; BYTE $0x00 // callq _format_integer, $2010(%rip) - WORD $0x3948; BYTE $0xd8 // cmpq %rbx, %rax - LONG $0x0154830f; WORD $0x0000 // jae LBB1_103, $340(%rip) - LONG $0xd0558b4c // movq $-48(%rbp), %r10 - WORD $0x014d; BYTE $0xd5 // addq %r10, %r13 - WORD $0x014d; BYTE $0xf5 // addq %r14, %r13 - WORD $0x2949; BYTE $0xc5 // subq %rax, %r13 - LONG $0x10fd8349 // cmpq $16, %r13 - LONG $0x01f1830f; WORD $0x0000 // jae LBB1_105, $497(%rip) - -LBB1_120: - WORD $0x8948; BYTE $0xc2 // movq %rax, %rdx - LONG $0x000372e9; BYTE $0x00 // jmp LBB1_121, $882(%rip) +LBB1_64: + WORD $0x8545; BYTE $0xc9 // testl %r9d, %r9d + LONG $0x013c880f; WORD $0x0000 // js LBB1_65, $316(%rip) + WORD $0x634d; BYTE $0xed // movslq %r13d, %r13 + LONG $0x2f1c8d4b // leaq (%r15,%r13), %rbx + WORD $0x894c; BYTE $0xfe // movq %r15, %rsi + LONG $0x0006c6e8; BYTE $0x00 // callq _format_integer, $1734(%rip) + WORD $0x3948; BYTE $0xd8 // cmpq %rbx, %rax + LONG $0x066d830f; WORD $0x0000 // jae LBB1_115, $1645(%rip) + WORD $0x014d; BYTE $0xec // addq %r13, %r12 + WORD $0x2949; BYTE $0xc4 // subq %rax, %r12 + WORD $0x014d; BYTE $0xf4 // addq %r14, %r12 + LONG $0x80fc8149; WORD $0x0000; BYTE $0x00 // cmpq $128, %r12 + LONG $0x0317820f; WORD $0x0000 // jb LBB1_114, $791(%rip) + WORD $0x894c; BYTE $0xe1 // movq %r12, %rcx + LONG $0x80e18348 // andq $-128, %rcx + LONG $0x80798d48 // leaq $-128(%rcx), %rdi + WORD $0x8948; BYTE $0xfe // movq %rdi, %rsi + LONG $0x07eec148 // shrq $7, %rsi + WORD $0xff48; BYTE $0xc6 // incq %rsi + WORD $0xf289 // movl %esi, %edx + WORD $0xe283; BYTE $0x03 // andl $3, %edx + LONG $0x80ff8148; WORD $0x0001; BYTE $0x00 // cmpq $384, %rdi + LONG $0x01fc830f; WORD $0x0000 // jae LBB1_107, $508(%rip) + WORD $0xff31 // xorl %edi, %edi + LONG $0x00029de9; BYTE $0x00 // jmp LBB1_109, $669(%rip) LBB1_11: WORD $0xd348; BYTE $0xef // shrq %cl, %rdi QUAD $0x0001ffffff80b848; WORD $0x0000 // movabsq $8589934464, %rax LONG $0xe47f0548; WORD $0x540b // addq $1410065535, %rax WORD $0x3948; BYTE $0xc7 // cmpq %rax, %rdi - LONG $0x0130860f; WORD $0x0000 // jbe LBB1_17, $304(%rip) + LONG $0x013f860f; WORD $0x0000 // jbe LBB1_18, $319(%rip) WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax LONG $0x0be8c148 // shrq $11, %rax LONG $0x00000bba; BYTE $0x00 // movl $11, %edx LONG $0x0edd3d48; WORD $0x02e9 // cmpq $48828125, %rax - LONG $0x01a2820f; WORD $0x0000 // jb LBB1_27, $418(%rip) + LONG $0x01b1820f; WORD $0x0000 // jb LBB1_28, $433(%rip) WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax LONG $0x0ce8c148 // shrq $12, %rax LONG $0x00000cba; BYTE $0x00 // movl $12, %edx LONG $0x4a513d48; WORD $0x0e8d // cmpq $244140625, %rax - LONG $0x018a820f; WORD $0x0000 // jb LBB1_27, $394(%rip) + LONG $0x0199820f; WORD $0x0000 // jb LBB1_28, $409(%rip) WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax LONG $0x0de8c148 // shrq $13, %rax LONG $0x00000dba; BYTE $0x00 // movl $13, %edx LONG $0x73953d48; WORD $0x48c2 // cmpq $1220703125, %rax - LONG $0x0172820f; WORD $0x0000 // jb LBB1_27, $370(%rip) + LONG $0x0181820f; WORD $0x0000 // jb LBB1_28, $385(%rip) LONG $0x00000eba; BYTE $0x00 // movl $14, %edx QUAD $0x5af3107a4000b848; WORD $0x0000 // movabsq $100000000000000, %rax WORD $0x3948; BYTE $0xc7 // cmpq %rax, %rdi - LONG $0x015a820f; WORD $0x0000 // jb LBB1_27, $346(%rip) + LONG $0x0169820f; WORD $0x0000 // jb LBB1_28, $361(%rip) + LONG $0x00000fba; BYTE $0x00 // movl $15, %edx QUAD $0x8d7ea4c68000b848; WORD $0x0003 // movabsq $1000000000000000, %rax WORD $0x3948; BYTE $0xc7 // cmpq %rax, %rdi - LONG $0x000010ba; BYTE $0x00 // movl $16, %edx + LONG $0x0151820f; WORD $0x0000 // jb LBB1_28, $337(%rip) + QUAD $0x86f26fc10000b848; WORD $0x0023 // movabsq $10000000000000000, %rax + WORD $0x3948; BYTE $0xc7 // cmpq %rax, %rdi + LONG $0x000011ba; BYTE $0x00 // movl $17, %edx -LBB1_26: +LBB1_27: WORD $0xda83; BYTE $0x00 // sbbl $0, %edx - LONG $0x000140e9; BYTE $0x00 // jmp LBB1_27, $320(%rip) + LONG $0x000137e9; BYTE $0x00 // jmp LBB1_28, $311(%rip) -LBB1_55: +LBB1_57: LONG $0x2d0143c6 // movb $45, $1(%rbx) - LONG $0x000001b8; BYTE $0x00 // movl $1, %eax - WORD $0x2944; BYTE $0xf0 // subl %r14d, %eax + WORD $0xd8f7 // negl %eax WORD $0xf883; BYTE $0x64 // cmpl $100, %eax - LONG $0xfee1830f; WORD $0xffff // jae LBB1_58, $-287(%rip) + LONG $0xfeaa8d0f; WORD $0xffff // jge LBB1_60, $-342(%rip) -LBB1_59: +LBB1_61: WORD $0xf883; BYTE $0x0a // cmpl $10, %eax - LONG $0x008a820f; WORD $0x0000 // jb LBB1_61, $138(%rip) + LONG $0x00878c0f; WORD $0x0000 // jl LBB1_63, $135(%rip) WORD $0xc089 // movl %eax, %eax - LONG $0xe50d8d48; WORD $0x00b2; BYTE $0x00 // leaq $45797(%rip), %rcx /* _Digits(%rip) */ + LONG $0xca0d8d48; WORD $0x00b5; BYTE $0x00 // leaq $46538(%rip), %rcx /* _Digits(%rip) */ LONG $0x4104b70f // movzwl (%rcx,%rax,2), %eax LONG $0x02438966 // movw %ax, $2(%rbx) LONG $0x04c38348 // addq $4, %rbx - LONG $0x0006a5e9; BYTE $0x00 // jmp LBB1_122, $1701(%rip) + LONG $0x000549e9; BYTE $0x00 // jmp LBB1_115, $1353(%rip) -LBB1_63: - WORD $0x8545; BYTE $0xf6 // testl %r14d, %r14d - LONG $0x03ca8f0f; WORD $0x0000 // jg LBB1_76, $970(%rip) +LBB1_65: + WORD $0x8545; BYTE $0xed // testl %r13d, %r13d + LONG $0x031f8f0f; WORD $0x0000 // jg LBB1_78, $799(%rip) LONG $0x07c74166; WORD $0x2e30 // movw $11824, (%r15) LONG $0x02c78349 // addq $2, %r15 - WORD $0x8545; BYTE $0xf6 // testl %r14d, %r14d - LONG $0x03b7890f; WORD $0x0000 // jns LBB1_76, $951(%rip) + WORD $0x8545; BYTE $0xed // testl %r13d, %r13d + LONG $0x030c890f; WORD $0x0000 // jns LBB1_78, $780(%rip) WORD $0x8941; BYTE $0xd0 // movl %edx, %r8d WORD $0xf741; BYTE $0xd0 // notl %r8d - WORD $0x2945; BYTE $0xd0 // subl %r10d, %r8d + WORD $0x2945; BYTE $0xc8 // subl %r9d, %r8d WORD $0xc031 // xorl %eax, %eax LONG $0x7ff88341 // cmpl $127, %r8d - LONG $0x038e820f; WORD $0x0000 // jb LBB1_74, $910(%rip) + LONG $0x02de820f; WORD $0x0000 // jb LBB1_76, $734(%rip) WORD $0xff49; BYTE $0xc0 // incq %r8 WORD $0x894c; BYTE $0xc0 // movq %r8, %rax - WORD $0x214c; BYTE $0xe0 // andq %r12, %rax + QUAD $0x0001ffffff80b948; WORD $0x0000 // movabsq $8589934464, %rcx + WORD $0x2148; BYTE $0xc8 // andq %rcx, %rax LONG $0x80488d48 // leaq $-128(%rax), %rcx WORD $0x8948; BYTE $0xce // movq %rcx, %rsi LONG $0x07eec148 // shrq $7, %rsi @@ -528,81 +448,56 @@ LBB1_63: WORD $0x8941; BYTE $0xf1 // movl %esi, %r9d LONG $0x03e18341 // andl $3, %r9d LONG $0x80f98148; WORD $0x0001; BYTE $0x00 // cmpq $384, %rcx - LONG $0x0264830f; WORD $0x0000 // jae LBB1_68, $612(%rip) + LONG $0x01b7830f; WORD $0x0000 // jae LBB1_70, $439(%rip) WORD $0xc931 // xorl %ecx, %ecx - LONG $0xd0558b4c // movq $-48(%rbp), %r10 - LONG $0x000307e9; BYTE $0x00 // jmp LBB1_70, $775(%rip) + LONG $0x00025ae9; BYTE $0x00 // jmp LBB1_72, $602(%rip) -LBB1_103: - LONG $0xd0558b4c // movq $-48(%rbp), %r10 - LONG $0x000635e9; BYTE $0x00 // jmp LBB1_122, $1589(%rip) - -LBB1_61: +LBB1_63: WORD $0x3004 // addb $48, %al WORD $0x4388; BYTE $0x02 // movb %al, $2(%rbx) LONG $0x03c38348 // addq $3, %rbx - LONG $0x000627e9; BYTE $0x00 // jmp LBB1_122, $1575(%rip) + LONG $0x0004cee9; BYTE $0x00 // jmp LBB1_115, $1230(%rip) -LBB1_17: +LBB1_18: LONG $0x000001ba; BYTE $0x00 // movl $1, %edx LONG $0x0aff8348 // cmpq $10, %rdi - LONG $0x007b820f; WORD $0x0000 // jb LBB1_27, $123(%rip) + LONG $0x007b820f; WORD $0x0000 // jb LBB1_28, $123(%rip) LONG $0x000002ba; BYTE $0x00 // movl $2, %edx LONG $0x64ff8348 // cmpq $100, %rdi - LONG $0x006c820f; WORD $0x0000 // jb LBB1_27, $108(%rip) + LONG $0x006c820f; WORD $0x0000 // jb LBB1_28, $108(%rip) LONG $0x000003ba; BYTE $0x00 // movl $3, %edx LONG $0xe8ff8148; WORD $0x0003; BYTE $0x00 // cmpq $1000, %rdi - LONG $0x005a820f; WORD $0x0000 // jb LBB1_27, $90(%rip) + LONG $0x005a820f; WORD $0x0000 // jb LBB1_28, $90(%rip) LONG $0x000004ba; BYTE $0x00 // movl $4, %edx LONG $0x10ff8148; WORD $0x0027; BYTE $0x00 // cmpq $10000, %rdi - LONG $0x0048820f; WORD $0x0000 // jb LBB1_27, $72(%rip) + LONG $0x0048820f; WORD $0x0000 // jb LBB1_28, $72(%rip) LONG $0x000005ba; BYTE $0x00 // movl $5, %edx LONG $0xa0ff8148; WORD $0x0186; BYTE $0x00 // cmpq $100000, %rdi - LONG $0x0036820f; WORD $0x0000 // jb LBB1_27, $54(%rip) + LONG $0x0036820f; WORD $0x0000 // jb LBB1_28, $54(%rip) LONG $0x000006ba; BYTE $0x00 // movl $6, %edx LONG $0x40ff8148; WORD $0x0f42; BYTE $0x00 // cmpq $1000000, %rdi - LONG $0x0024820f; WORD $0x0000 // jb LBB1_27, $36(%rip) + LONG $0x0024820f; WORD $0x0000 // jb LBB1_28, $36(%rip) LONG $0x000007ba; BYTE $0x00 // movl $7, %edx LONG $0x80ff8148; WORD $0x9896; BYTE $0x00 // cmpq $10000000, %rdi - LONG $0x0012820f; WORD $0x0000 // jb LBB1_27, $18(%rip) + LONG $0x0012820f; WORD $0x0000 // jb LBB1_28, $18(%rip) LONG $0x000008ba; BYTE $0x00 // movl $8, %edx LONG $0x00ff8148; WORD $0xf5e1; BYTE $0x05 // cmpq $100000000, %rdi - LONG $0x05c8830f; WORD $0x0000 // jae LBB1_25, $1480(%rip) + LONG $0x0480830f; WORD $0x0000 // jae LBB1_26, $1152(%rip) -LBB1_27: +LBB1_28: WORD $0x894c; BYTE $0xfe // movq %r15, %rsi - LONG $0x0005d4e8; BYTE $0x00 // callq _format_integer, $1492(%rip) + LONG $0x00048ce8; BYTE $0x00 // callq _format_integer, $1164(%rip) WORD $0x8948; BYTE $0xc3 // movq %rax, %rbx - WORD $0x5d2b; BYTE $0xd0 // subl $-48(%rbp), %ebx - LONG $0x00058de9; BYTE $0x00 // jmp LBB1_123, $1421(%rip) - -LBB1_105: - LONG $0x80fd8149; WORD $0x0000; BYTE $0x00 // cmpq $128, %r13 - LONG $0x0007830f; WORD $0x0000 // jae LBB1_110, $7(%rip) - WORD $0xc931 // xorl %ecx, %ecx - LONG $0x00013ce9; BYTE $0x00 // jmp LBB1_107, $316(%rip) + LONG $0x000434e9; BYTE $0x00 // jmp LBB1_115, $1076(%rip) -LBB1_110: - WORD $0x894c; BYTE $0xe9 // movq %r13, %rcx - LONG $0x80e18348 // andq $-128, %rcx - LONG $0x80798d48 // leaq $-128(%rcx), %rdi - WORD $0x8948; BYTE $0xfe // movq %rdi, %rsi - LONG $0x07eec148 // shrq $7, %rsi - WORD $0xff48; BYTE $0xc6 // incq %rsi - WORD $0xf289 // movl %esi, %edx - WORD $0xe283; BYTE $0x03 // andl $3, %edx - LONG $0x80ff8148; WORD $0x0001; BYTE $0x00 // cmpq $384, %rdi - LONG $0x0007830f; WORD $0x0000 // jae LBB1_112, $7(%rip) - WORD $0xff31 // xorl %edi, %edi - LONG $0x0000abe9; BYTE $0x00 // jmp LBB1_114, $171(%rip) - -LBB1_112: - LONG $0xfce68348 // andq $-4, %rsi - WORD $0xff31 // xorl %edi, %edi - QUAD $0xfffff8d9056ffdc5 // vmovdqa $-1831(%rip), %ymm0 /* LCPI1_0(%rip) */ - QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90 +LBB1_107: + LONG $0xfce68348 // andq $-4, %rsi + WORD $0xf748; BYTE $0xde // negq %rsi + WORD $0xff31 // xorl %edi, %edi + QUAD $0xfffff923056ffdc5 // vmovdqa $-1757(%rip), %ymm0 /* LCPI1_0(%rip) */ + WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 -LBB1_113: +LBB1_108: LONG $0x047ffec5; BYTE $0x38 // vmovdqu %ymm0, (%rax,%rdi) LONG $0x447ffec5; WORD $0x2038 // vmovdqu %ymm0, $32(%rax,%rdi) LONG $0x447ffec5; WORD $0x4038 // vmovdqu %ymm0, $64(%rax,%rdi) @@ -620,71 +515,47 @@ LBB1_113: QUAD $0x0001c038847ffec5; BYTE $0x00 // vmovdqu %ymm0, $448(%rax,%rdi) QUAD $0x0001e038847ffec5; BYTE $0x00 // vmovdqu %ymm0, $480(%rax,%rdi) LONG $0x00c78148; WORD $0x0002; BYTE $0x00 // addq $512, %rdi - LONG $0xfcc68348 // addq $-4, %rsi - LONG $0xff6c850f; WORD $0xffff // jne LBB1_113, $-148(%rip) + LONG $0x04c68348 // addq $4, %rsi + LONG $0xff6c850f; WORD $0xffff // jne LBB1_108, $-148(%rip) -LBB1_114: - WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx - LONG $0x0047840f; WORD $0x0000 // je LBB1_117, $71(%rip) - LONG $0x07348d48 // leaq (%rdi,%rax), %rsi - LONG $0x60c68348 // addq $96, %rsi - LONG $0x07e2c148 // shlq $7, %rdx - WORD $0xff31 // xorl %edi, %edi - QUAD $0xfffff81d056ffdc5 // vmovdqa $-2019(%rip), %ymm0 /* LCPI1_0(%rip) */ - QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 - -LBB1_116: - LONG $0x447ffec5; WORD $0xa03e // vmovdqu %ymm0, $-96(%rsi,%rdi) - LONG $0x447ffec5; WORD $0xc03e // vmovdqu %ymm0, $-64(%rsi,%rdi) - LONG $0x447ffec5; WORD $0xe03e // vmovdqu %ymm0, $-32(%rsi,%rdi) - LONG $0x047ffec5; BYTE $0x3e // vmovdqu %ymm0, (%rsi,%rdi) - LONG $0x80ef8348 // subq $-128, %rdi - WORD $0x3948; BYTE $0xfa // cmpq %rdi, %rdx - LONG $0xffdc850f; WORD $0xffff // jne LBB1_116, $-36(%rip) - -LBB1_117: - WORD $0x3949; BYTE $0xcd // cmpq %rcx, %r13 - LONG $0x0444840f; WORD $0x0000 // je LBB1_122, $1092(%rip) - LONG $0x70c5f641 // testb $112, %r13b - LONG $0x004d840f; WORD $0x0000 // je LBB1_119, $77(%rip) - -LBB1_107: - WORD $0x894c; BYTE $0xee // movq %r13, %rsi - LONG $0xf0e68348 // andq $-16, %rsi - WORD $0x8948; BYTE $0xc2 // movq %rax, %rdx - WORD $0x0148; BYTE $0xf2 // addq %rsi, %rdx - QUAD $0xfffff7e4056ff9c5 // vmovdqa $-2076(%rip), %xmm0 /* LCPI1_1(%rip) */ - LONG $0x90909090 // .p2align 4, 0x90 - -LBB1_108: - LONG $0x047ffac5; BYTE $0x08 // vmovdqu %xmm0, (%rax,%rcx) - LONG $0x10c18348 // addq $16, %rcx - WORD $0x3948; BYTE $0xce // cmpq %rcx, %rsi - LONG $0xffee850f; WORD $0xffff // jne LBB1_108, $-18(%rip) - WORD $0x3949; BYTE $0xf5 // cmpq %rsi, %r13 - LONG $0x0406840f; WORD $0x0000 // je LBB1_122, $1030(%rip) - LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 +LBB1_109: + WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx + LONG $0x0033840f; WORD $0x0000 // je LBB1_112, $51(%rip) + LONG $0x07748d48; BYTE $0x60 // leaq $96(%rdi,%rax), %rsi + WORD $0xf748; BYTE $0xda // negq %rdx + QUAD $0xfffff873056ffdc5 // vmovdqa $-1933(%rip), %ymm0 /* LCPI1_0(%rip) */ + WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 -LBB1_121: - WORD $0x02c6; BYTE $0x30 // movb $48, (%rdx) +LBB1_111: + LONG $0x467ffec5; BYTE $0xa0 // vmovdqu %ymm0, $-96(%rsi) + LONG $0x467ffec5; BYTE $0xc0 // vmovdqu %ymm0, $-64(%rsi) + LONG $0x467ffec5; BYTE $0xe0 // vmovdqu %ymm0, $-32(%rsi) + LONG $0x067ffec5 // vmovdqu %ymm0, (%rsi) + LONG $0x80ee8348 // subq $-128, %rsi WORD $0xff48; BYTE $0xc2 // incq %rdx - WORD $0x3948; BYTE $0xda // cmpq %rbx, %rdx - LONG $0xfff1820f; WORD $0xffff // jb LBB1_121, $-15(%rip) - LONG $0x0003ede9; BYTE $0x00 // jmp LBB1_122, $1005(%rip) + LONG $0xffe0850f; WORD $0xffff // jne LBB1_111, $-32(%rip) -LBB1_119: - WORD $0x0148; BYTE $0xc8 // addq %rcx, %rax - LONG $0xfffc6ae9; BYTE $0xff // jmp LBB1_120, $-918(%rip) +LBB1_112: + WORD $0x394c; BYTE $0xe1 // cmpq %r12, %rcx + LONG $0x0347840f; WORD $0x0000 // je LBB1_115, $839(%rip) + WORD $0x0148; BYTE $0xc8 // addq %rcx, %rax + LONG $0x90909090 // .p2align 4, 0x90 -LBB1_68: - LONG $0xfce68348 // andq $-4, %rsi - LONG $0xd0558b4c // movq $-48(%rbp), %r10 - LONG $0x2a1c8d4b // leaq (%r10,%r13), %rbx - LONG $0xe2c38148; WORD $0x0001; BYTE $0x00 // addq $482, %rbx - WORD $0xc931 // xorl %ecx, %ecx - QUAD $0xfffff767056ffdc5 // vmovdqa $-2201(%rip), %ymm0 /* LCPI1_0(%rip) */ +LBB1_114: + WORD $0x00c6; BYTE $0x30 // movb $48, (%rax) + WORD $0xff48; BYTE $0xc0 // incq %rax + WORD $0x3948; BYTE $0xc3 // cmpq %rax, %rbx + LONG $0xfff1850f; WORD $0xffff // jne LBB1_114, $-15(%rip) + LONG $0x00032ce9; BYTE $0x00 // jmp LBB1_115, $812(%rip) -LBB1_69: +LBB1_70: + QUAD $0x000001e2349c8d4b // leaq $482(%r12,%r14), %rbx + LONG $0xfce68348 // andq $-4, %rsi + WORD $0xf748; BYTE $0xde // negq %rsi + WORD $0xc931 // xorl %ecx, %ecx + QUAD $0xfffff813056ffdc5 // vmovdqa $-2029(%rip), %ymm0 /* LCPI1_0(%rip) */ + +LBB1_71: QUAD $0xfffe200b847ffec5; BYTE $0xff // vmovdqu %ymm0, $-480(%rbx,%rcx) QUAD $0xfffe400b847ffec5; BYTE $0xff // vmovdqu %ymm0, $-448(%rbx,%rcx) QUAD $0xfffe600b847ffec5; BYTE $0xff // vmovdqu %ymm0, $-416(%rbx,%rcx) @@ -702,241 +573,192 @@ LBB1_69: LONG $0x447ffec5; WORD $0xe00b // vmovdqu %ymm0, $-32(%rbx,%rcx) LONG $0x047ffec5; BYTE $0x0b // vmovdqu %ymm0, (%rbx,%rcx) LONG $0x00c18148; WORD $0x0002; BYTE $0x00 // addq $512, %rcx - LONG $0xfcc68348 // addq $-4, %rsi - LONG $0xff6f850f; WORD $0xffff // jne LBB1_69, $-145(%rip) + LONG $0x04c68348 // addq $4, %rsi + LONG $0xff6f850f; WORD $0xffff // jne LBB1_71, $-145(%rip) -LBB1_70: +LBB1_72: WORD $0x854d; BYTE $0xc9 // testq %r9, %r9 - LONG $0x003c840f; WORD $0x0000 // je LBB1_73, $60(%rip) - WORD $0x014c; BYTE $0xe9 // addq %r13, %rcx - WORD $0x014c; BYTE $0xd1 // addq %r10, %rcx - LONG $0x62c18348 // addq $98, %rcx - LONG $0x07e1c149 // shlq $7, %r9 - WORD $0xf631 // xorl %esi, %esi - QUAD $0xfffff6b5056ffdc5 // vmovdqa $-2379(%rip), %ymm0 /* LCPI1_0(%rip) */ + LONG $0x0033840f; WORD $0x0000 // je LBB1_75, $51(%rip) + WORD $0x014c; BYTE $0xe1 // addq %r12, %rcx + LONG $0x0e4c8d49; BYTE $0x62 // leaq $98(%r14,%rcx), %rcx + WORD $0xf749; BYTE $0xd9 // negq %r9 + QUAD $0xfffff766056ffdc5 // vmovdqa $-2202(%rip), %ymm0 /* LCPI1_0(%rip) */ -LBB1_72: - LONG $0x447ffec5; WORD $0xa031 // vmovdqu %ymm0, $-96(%rcx,%rsi) - LONG $0x447ffec5; WORD $0xc031 // vmovdqu %ymm0, $-64(%rcx,%rsi) - LONG $0x447ffec5; WORD $0xe031 // vmovdqu %ymm0, $-32(%rcx,%rsi) - LONG $0x047ffec5; BYTE $0x31 // vmovdqu %ymm0, (%rcx,%rsi) - LONG $0x80ee8348 // subq $-128, %rsi - WORD $0x3949; BYTE $0xf1 // cmpq %rsi, %r9 - LONG $0xffdc850f; WORD $0xffff // jne LBB1_72, $-36(%rip) +LBB1_74: + LONG $0x417ffec5; BYTE $0xa0 // vmovdqu %ymm0, $-96(%rcx) + LONG $0x417ffec5; BYTE $0xc0 // vmovdqu %ymm0, $-64(%rcx) + LONG $0x417ffec5; BYTE $0xe0 // vmovdqu %ymm0, $-32(%rcx) + LONG $0x017ffec5 // vmovdqu %ymm0, (%rcx) + LONG $0x80e98348 // subq $-128, %rcx + WORD $0xff49; BYTE $0xc1 // incq %r9 + LONG $0xffe0850f; WORD $0xffff // jne LBB1_74, $-32(%rip) -LBB1_73: +LBB1_75: WORD $0x0149; BYTE $0xc7 // addq %rax, %r15 WORD $0x3949; BYTE $0xc0 // cmpq %rax, %r8 - LONG $0x0014840f; WORD $0x0000 // je LBB1_76, $20(%rip) + LONG $0x0019840f; WORD $0x0000 // je LBB1_78, $25(%rip) -LBB1_74: - WORD $0x0144; BYTE $0xf0 // addl %r14d, %eax - WORD $0xd8f7 // negl %eax +LBB1_76: + WORD $0x0144; BYTE $0xe8 // addl %r13d, %eax + WORD $0xd8f7 // negl %eax + LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 - // .p2align 4, 0x90 -LBB1_75: +LBB1_77: LONG $0x3007c641 // movb $48, (%r15) WORD $0xff49; BYTE $0xc7 // incq %r15 WORD $0xc8ff // decl %eax - LONG $0xfff1850f; WORD $0xffff // jne LBB1_75, $-15(%rip) + LONG $0xfff1850f; WORD $0xffff // jne LBB1_77, $-15(%rip) -LBB1_76: - WORD $0x894c; BYTE $0xfe // movq %r15, %rsi - WORD $0xf8c5; BYTE $0x77 // vzeroupper - LONG $0x007706e8; BYTE $0x00 // callq _format_significand, $30470(%rip) - WORD $0xc389 // movl %eax, %ebx - WORD $0x2844; BYTE $0xfb // subb %r15b, %bl - WORD $0x2844; BYTE $0xf3 // subb %r14b, %bl - LONG $0x3e2c8d47 // leal (%r14,%r15), %r13d - WORD $0x2941; BYTE $0xc5 // subl %eax, %r13d - LONG $0xff458d45 // leal $-1(%r13), %r8d - LONG $0xfe7d8d41 // leal $-2(%r13), %edi - WORD $0xc931 // xorl %ecx, %ecx - QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 +LBB1_78: + WORD $0x894c; BYTE $0xfe // movq %r15, %rsi + WORD $0xf8c5; BYTE $0x77 // vzeroupper + LONG $0x007dc6e8; BYTE $0x00 // callq _format_significand, $32198(%rip) + LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 -LBB1_77: +LBB1_79: + LONG $0x30ff7880 // cmpb $48, $-1(%rax) + LONG $0xff408d48 // leaq $-1(%rax), %rax + LONG $0xfff2840f; WORD $0xffff // je LBB1_79, $-14(%rip) + LONG $0x01588d48 // leaq $1(%rax), %rbx + WORD $0x8545; BYTE $0xed // testl %r13d, %r13d + LONG $0x01f58e0f; WORD $0x0000 // jle LBB1_115, $501(%rip) WORD $0xda89 // movl %ebx, %edx - WORD $0x5a8d; BYTE $0x03 // leal $3(%rdx), %ebx - WORD $0xc7ff // incl %edi - LONG $0xff087c80; BYTE $0x30 // cmpb $48, $-1(%rax,%rcx) - LONG $0xff498d48 // leaq $-1(%rcx), %rcx - LONG $0xffea840f; WORD $0xffff // je LBB1_77, $-22(%rip) - LONG $0x081c8d48 // leaq (%rax,%rcx), %rbx - WORD $0xff48; BYTE $0xc3 // incq %rbx - WORD $0x8545; BYTE $0xf6 // testl %r14d, %r14d - LONG $0xd0558b4c // movq $-48(%rbp), %r10 - LONG $0x02778e0f; WORD $0x0000 // jle LBB1_122, $631(%rip) - WORD $0xc689 // movl %eax, %esi - WORD $0x2944; BYTE $0xfe // subl %r15d, %esi - WORD $0xce01 // addl %ecx, %esi - WORD $0xc6ff // incl %esi - WORD $0x3941; BYTE $0xf6 // cmpl %esi, %r14d - LONG $0x00308d0f; WORD $0x0000 // jge LBB1_80, $48(%rip) - WORD $0x8941; BYTE $0xc1 // movl %eax, %r9d - WORD $0x2945; BYTE $0xf1 // subl %r14d, %r9d - WORD $0x2945; BYTE $0xf9 // subl %r15d, %r9d - WORD $0xff41; BYTE $0xc1 // incl %r9d - LONG $0x093c8d49 // leaq (%r9,%rcx), %rdi - WORD $0xff85 // testl %edi, %edi - LONG $0x00e48e0f; WORD $0x0000 // jle LBB1_99, $228(%rip) - WORD $0x8941; BYTE $0xf8 // movl %edi, %r8d - LONG $0xff588d49 // leaq $-1(%r8), %rbx - LONG $0x03fb8348 // cmpq $3, %rbx - LONG $0x006c830f; WORD $0x0000 // jae LBB1_100, $108(%rip) - WORD $0xdb31 // xorl %ebx, %ebx - LONG $0x000090e9; BYTE $0x00 // jmp LBB1_96, $144(%rip) + WORD $0x2944; BYTE $0xfa // subl %r15d, %edx + WORD $0x8944; BYTE $0xe9 // movl %r13d, %ecx + WORD $0xd129 // subl %edx, %ecx + LONG $0x00258d0f; WORD $0x0000 // jge LBB1_82, $37(%rip) + WORD $0x2944; BYTE $0xea // subl %r13d, %edx + LONG $0x00c48e0f; WORD $0x0000 // jle LBB1_100, $196(%rip) + WORD $0xd689 // movl %edx, %esi + LONG $0xff568d48 // leaq $-1(%rsi), %rdx + WORD $0xf189 // movl %esi, %ecx + WORD $0xe183; BYTE $0x03 // andl $3, %ecx + LONG $0x03fa8348 // cmpq $3, %rdx + LONG $0x005c830f; WORD $0x0000 // jae LBB1_101, $92(%rip) + WORD $0xd231 // xorl %edx, %edx + LONG $0x000078e9; BYTE $0x00 // jmp LBB1_97, $120(%rip) -LBB1_80: - WORD $0x8945; BYTE $0xc3 // movl %r8d, %r11d - WORD $0x2949; BYTE $0xcb // subq %rcx, %r11 - WORD $0x8545; BYTE $0xdb // testl %r11d, %r11d - LONG $0x02268e0f; WORD $0x0000 // jle LBB1_122, $550(%rip) - WORD $0x0145; BYTE $0xfe // addl %r15d, %r14d - WORD $0x2941; BYTE $0xc6 // subl %eax, %r14d - LONG $0xfec68341 // addl $-2, %r14d - WORD $0x2949; BYTE $0xce // subq %rcx, %r14 +LBB1_82: + LONG $0x01ba8e0f; WORD $0x0000 // jle LBB1_115, $442(%rip) + WORD $0x0145; BYTE $0xfd // addl %r15d, %r13d + WORD $0x8941; BYTE $0xd8 // movl %ebx, %r8d + WORD $0xf741; BYTE $0xd0 // notl %r8d + WORD $0x0145; BYTE $0xe8 // addl %r13d, %r8d WORD $0xd231 // xorl %edx, %edx - LONG $0x7ffe8341 // cmpl $127, %r14d - LONG $0x01fc820f; WORD $0x0000 // jb LBB1_91, $508(%rip) - LONG $0xfec58341 // addl $-2, %r13d - WORD $0x2949; BYTE $0xcd // subq %rcx, %r13 - WORD $0x8945; BYTE $0xf0 // movl %r14d, %r8d + LONG $0x7ef88341 // cmpl $126, %r8d + LONG $0x0192860f; WORD $0x0000 // jbe LBB1_92, $402(%rip) WORD $0xff49; BYTE $0xc0 // incq %r8 - WORD $0x214d; BYTE $0xc4 // andq %r8, %r12 - WORD $0x8941; BYTE $0xf9 // movl %edi, %r9d - WORD $0xff49; BYTE $0xc1 // incq %r9 - LONG $0x80e18349 // andq $-128, %r9 - LONG $0x24548d49; BYTE $0x80 // leaq $-128(%r12), %rdx - WORD $0x8949; BYTE $0xd2 // movq %rdx, %r10 - LONG $0x07eac149 // shrq $7, %r10 - WORD $0xff49; BYTE $0xc2 // incq %r10 + QUAD $0x0001ffffff80b949; WORD $0x0000 // movabsq $8589934464, %r9 + WORD $0x214d; BYTE $0xc1 // andq %r8, %r9 + LONG $0x80518d49 // leaq $-128(%r9), %rdx + WORD $0x8948; BYTE $0xd7 // movq %rdx, %rdi + LONG $0x07efc148 // shrq $7, %rdi + WORD $0xff48; BYTE $0xc7 // incq %rdi + WORD $0xfe89 // movl %edi, %esi + WORD $0xe683; BYTE $0x03 // andl $3, %esi LONG $0x80fa8148; WORD $0x0001; BYTE $0x00 // cmpq $384, %rdx - LONG $0x0083830f; WORD $0x0000 // jae LBB1_84, $131(%rip) - WORD $0xff31 // xorl %edi, %edi - LONG $0x000138e9; BYTE $0x00 // jmp LBB1_86, $312(%rip) + LONG $0x006e830f; WORD $0x0000 // jae LBB1_86, $110(%rip) + WORD $0xd231 // xorl %edx, %edx + LONG $0x00010de9; BYTE $0x00 // jmp LBB1_88, $269(%rip) -LBB1_100: - WORD $0x0149; BYTE $0xc9 // addq %rcx, %r9 - LONG $0xfce18341 // andl $-4, %r9d - WORD $0xf749; BYTE $0xd9 // negq %r9 - WORD $0xdb31 // xorl %ebx, %ebx +LBB1_101: + WORD $0xe683; BYTE $0xfc // andl $-4, %esi + WORD $0xf748; BYTE $0xde // negq %rsi + WORD $0xd231 // xorl %edx, %edx WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 -LBB1_101: - LONG $0x183c8d48 // leaq (%rax,%rbx), %rdi - LONG $0xfd39748b // movl $-3(%rcx,%rdi), %esi - LONG $0xfe397489 // movl %esi, $-2(%rcx,%rdi) - LONG $0xfcc38348 // addq $-4, %rbx - WORD $0x3949; BYTE $0xd9 // cmpq %rbx, %r9 - LONG $0xffe7850f; WORD $0xffff // jne LBB1_101, $-25(%rip) - WORD $0xf748; BYTE $0xdb // negq %rbx - -LBB1_96: - LONG $0x03c0f641 // testb $3, %r8b - LONG $0x0032840f; WORD $0x0000 // je LBB1_99, $50(%rip) - LONG $0xc2b60f44 // movzbl %dl, %r8d - LONG $0x03e08341 // andl $3, %r8d - WORD $0xf749; BYTE $0xd8 // negq %r8 - WORD $0x8948; BYTE $0xc6 // movq %rax, %rsi - WORD $0x2948; BYTE $0xde // subq %rbx, %rsi - WORD $0xff31 // xorl %edi, %edi - LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 +LBB1_102: + LONG $0xfd107c8b // movl $-3(%rax,%rdx), %edi + LONG $0xfe107c89 // movl %edi, $-2(%rax,%rdx) + LONG $0xfcc28348 // addq $-4, %rdx + WORD $0x3948; BYTE $0xd6 // cmpq %rdx, %rsi + LONG $0xffeb850f; WORD $0xffff // jne LBB1_102, $-21(%rip) + WORD $0xf748; BYTE $0xda // negq %rdx -LBB1_98: - LONG $0x3e1c8d48 // leaq (%rsi,%rdi), %rbx - LONG $0x1914b60f // movzbl (%rcx,%rbx), %edx - LONG $0x01195488 // movb %dl, $1(%rcx,%rbx) - WORD $0xff48; BYTE $0xcf // decq %rdi - WORD $0x3949; BYTE $0xf8 // cmpq %rdi, %r8 - LONG $0xffe8850f; WORD $0xffff // jne LBB1_98, $-24(%rip) +LBB1_97: + WORD $0x8548; BYTE $0xc9 // testq %rcx, %rcx + LONG $0x0027840f; WORD $0x0000 // je LBB1_100, $39(%rip) + WORD $0xf748; BYTE $0xda // negq %rdx + WORD $0xf748; BYTE $0xd9 // negq %rcx + WORD $0xf631 // xorl %esi, %esi + LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 LBB1_99: - WORD $0x8944; BYTE $0xf2 // movl %r14d, %edx - LONG $0x1704c641; BYTE $0x2e // movb $46, (%r15,%rdx) - LONG $0x081c8d48 // leaq (%rax,%rcx), %rbx - LONG $0x02c38348 // addq $2, %rbx - LONG $0x000154e9; BYTE $0x00 // jmp LBB1_122, $340(%rip) + LONG $0x323c8d48 // leaq (%rdx,%rsi), %rdi + LONG $0x381cb60f // movzbl (%rax,%rdi), %ebx + LONG $0x01385c88 // movb %bl, $1(%rax,%rdi) + WORD $0xff48; BYTE $0xce // decq %rsi + WORD $0x3948; BYTE $0xf1 // cmpq %rsi, %rcx + LONG $0xffe8850f; WORD $0xffff // jne LBB1_99, $-24(%rip) -LBB1_84: - WORD $0x8944; BYTE $0xeb // movl %r13d, %ebx - WORD $0xff48; BYTE $0xc3 // incq %rbx - LONG $0x80e38348 // andq $-128, %rbx - LONG $0x80c38348 // addq $-128, %rbx - LONG $0x07ebc148 // shrq $7, %rbx - WORD $0xff48; BYTE $0xc3 // incq %rbx - LONG $0xfce38348 // andq $-4, %rbx - WORD $0xff31 // xorl %edi, %edi - QUAD $0xfffff4d0056ffdc5 // vmovdqa $-2864(%rip), %ymm0 /* LCPI1_0(%rip) */ - -LBB1_85: - LONG $0x38148d48 // leaq (%rax,%rdi), %rdx - LONG $0x447ffec5; WORD $0x0111 // vmovdqu %ymm0, $1(%rcx,%rdx) - LONG $0x447ffec5; WORD $0x2111 // vmovdqu %ymm0, $33(%rcx,%rdx) - LONG $0x447ffec5; WORD $0x4111 // vmovdqu %ymm0, $65(%rcx,%rdx) - LONG $0x447ffec5; WORD $0x6111 // vmovdqu %ymm0, $97(%rcx,%rdx) - QUAD $0x00008111847ffec5; BYTE $0x00 // vmovdqu %ymm0, $129(%rcx,%rdx) - QUAD $0x0000a111847ffec5; BYTE $0x00 // vmovdqu %ymm0, $161(%rcx,%rdx) - QUAD $0x0000c111847ffec5; BYTE $0x00 // vmovdqu %ymm0, $193(%rcx,%rdx) - QUAD $0x0000e111847ffec5; BYTE $0x00 // vmovdqu %ymm0, $225(%rcx,%rdx) - QUAD $0x00010111847ffec5; BYTE $0x00 // vmovdqu %ymm0, $257(%rcx,%rdx) - QUAD $0x00012111847ffec5; BYTE $0x00 // vmovdqu %ymm0, $289(%rcx,%rdx) - QUAD $0x00014111847ffec5; BYTE $0x00 // vmovdqu %ymm0, $321(%rcx,%rdx) - QUAD $0x00016111847ffec5; BYTE $0x00 // vmovdqu %ymm0, $353(%rcx,%rdx) - QUAD $0x00018111847ffec5; BYTE $0x00 // vmovdqu %ymm0, $385(%rcx,%rdx) - QUAD $0x0001a111847ffec5; BYTE $0x00 // vmovdqu %ymm0, $417(%rcx,%rdx) - QUAD $0x0001c111847ffec5; BYTE $0x00 // vmovdqu %ymm0, $449(%rcx,%rdx) - QUAD $0x0001e111847ffec5; BYTE $0x00 // vmovdqu %ymm0, $481(%rcx,%rdx) - LONG $0x00c78148; WORD $0x0002; BYTE $0x00 // addq $512, %rdi - LONG $0xfcc38348 // addq $-4, %rbx - LONG $0xff67850f; WORD $0xffff // jne LBB1_85, $-153(%rip) +LBB1_100: + WORD $0x6349; BYTE $0xcd // movslq %r13d, %rcx + LONG $0x0f04c641; BYTE $0x2e // movb $46, (%r15,%rcx) + LONG $0x02c08348 // addq $2, %rax + WORD $0x8948; BYTE $0xc3 // movq %rax, %rbx + LONG $0x000104e9; BYTE $0x00 // jmp LBB1_115, $260(%rip) LBB1_86: - WORD $0x0149; BYTE $0xc1 // addq %rax, %r9 - LONG $0x03c2f641 // testb $3, %r10b - LONG $0x0059840f; WORD $0x0000 // je LBB1_89, $89(%rip) - WORD $0xff41; BYTE $0xc5 // incl %r13d - LONG $0x80e58141; WORD $0x0001; BYTE $0x00 // andl $384, %r13d - LONG $0x80c58341 // addl $-128, %r13d - LONG $0x07edc141 // shrl $7, %r13d - WORD $0xfe41; BYTE $0xc5 // incb %r13b - LONG $0xd5b60f41 // movzbl %r13b, %edx - WORD $0xe283; BYTE $0x03 // andl $3, %edx - LONG $0x07e2c148 // shlq $7, %rdx - WORD $0x0148; BYTE $0xf8 // addq %rdi, %rax - LONG $0x61c08348 // addq $97, %rax - WORD $0xf631 // xorl %esi, %esi - QUAD $0xfffff3f9056ffdc5 // vmovdqa $-3079(%rip), %ymm0 /* LCPI1_0(%rip) */ + LONG $0xfce78348 // andq $-4, %rdi + WORD $0xf748; BYTE $0xdf // negq %rdi + WORD $0xd231 // xorl %edx, %edx + QUAD $0xfffff5f3056ffdc5 // vmovdqa $-2573(%rip), %ymm0 /* LCPI1_0(%rip) */ + +LBB1_87: + LONG $0x447ffec5; WORD $0x0110 // vmovdqu %ymm0, $1(%rax,%rdx) + LONG $0x447ffec5; WORD $0x2110 // vmovdqu %ymm0, $33(%rax,%rdx) + LONG $0x447ffec5; WORD $0x4110 // vmovdqu %ymm0, $65(%rax,%rdx) + LONG $0x447ffec5; WORD $0x6110 // vmovdqu %ymm0, $97(%rax,%rdx) + QUAD $0x00008110847ffec5; BYTE $0x00 // vmovdqu %ymm0, $129(%rax,%rdx) + QUAD $0x0000a110847ffec5; BYTE $0x00 // vmovdqu %ymm0, $161(%rax,%rdx) + QUAD $0x0000c110847ffec5; BYTE $0x00 // vmovdqu %ymm0, $193(%rax,%rdx) + QUAD $0x0000e110847ffec5; BYTE $0x00 // vmovdqu %ymm0, $225(%rax,%rdx) + QUAD $0x00010110847ffec5; BYTE $0x00 // vmovdqu %ymm0, $257(%rax,%rdx) + QUAD $0x00012110847ffec5; BYTE $0x00 // vmovdqu %ymm0, $289(%rax,%rdx) + QUAD $0x00014110847ffec5; BYTE $0x00 // vmovdqu %ymm0, $321(%rax,%rdx) + QUAD $0x00016110847ffec5; BYTE $0x00 // vmovdqu %ymm0, $353(%rax,%rdx) + QUAD $0x00018110847ffec5; BYTE $0x00 // vmovdqu %ymm0, $385(%rax,%rdx) + QUAD $0x0001a110847ffec5; BYTE $0x00 // vmovdqu %ymm0, $417(%rax,%rdx) + QUAD $0x0001c110847ffec5; BYTE $0x00 // vmovdqu %ymm0, $449(%rax,%rdx) + QUAD $0x0001e110847ffec5; BYTE $0x00 // vmovdqu %ymm0, $481(%rax,%rdx) + LONG $0x00c28148; WORD $0x0002; BYTE $0x00 // addq $512, %rdx + LONG $0x04c78348 // addq $4, %rdi + LONG $0xff6b850f; WORD $0xffff // jne LBB1_87, $-149(%rip) LBB1_88: - LONG $0x303c8d48 // leaq (%rax,%rsi), %rdi - LONG $0x447ffec5; WORD $0xa039 // vmovdqu %ymm0, $-96(%rcx,%rdi) - LONG $0x447ffec5; WORD $0xc039 // vmovdqu %ymm0, $-64(%rcx,%rdi) - LONG $0x447ffec5; WORD $0xe039 // vmovdqu %ymm0, $-32(%rcx,%rdi) - LONG $0x047ffec5; BYTE $0x39 // vmovdqu %ymm0, (%rcx,%rdi) - LONG $0x80ee8348 // subq $-128, %rsi - WORD $0x3948; BYTE $0xf2 // cmpq %rsi, %rdx - LONG $0xffd8850f; WORD $0xffff // jne LBB1_88, $-40(%rip) - -LBB1_89: - LONG $0x091c8d4a // leaq (%rcx,%r9), %rbx - WORD $0xff48; BYTE $0xc3 // incq %rbx - WORD $0x394d; BYTE $0xe0 // cmpq %r12, %r8 - LONG $0xd0558b4c // movq $-48(%rbp), %r10 - LONG $0x001e840f; WORD $0x0000 // je LBB1_122, $30(%rip) - WORD $0x8944; BYTE $0xe2 // movl %r12d, %edx - QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90 + LONG $0x085c8d4a; BYTE $0x01 // leaq $1(%rax,%r9), %rbx + WORD $0x8548; BYTE $0xf6 // testq %rsi, %rsi + LONG $0x0030840f; WORD $0x0000 // je LBB1_91, $48(%rip) + LONG $0x10448d48; BYTE $0x61 // leaq $97(%rax,%rdx), %rax + WORD $0xf748; BYTE $0xde // negq %rsi + QUAD $0xfffff540056ffdc5 // vmovdqa $-2752(%rip), %ymm0 /* LCPI1_0(%rip) */ + +LBB1_90: + LONG $0x407ffec5; BYTE $0xa0 // vmovdqu %ymm0, $-96(%rax) + LONG $0x407ffec5; BYTE $0xc0 // vmovdqu %ymm0, $-64(%rax) + LONG $0x407ffec5; BYTE $0xe0 // vmovdqu %ymm0, $-32(%rax) + LONG $0x007ffec5 // vmovdqu %ymm0, (%rax) + LONG $0x80e88348 // subq $-128, %rax + WORD $0xff48; BYTE $0xc6 // incq %rsi + LONG $0xffe0850f; WORD $0xffff // jne LBB1_90, $-32(%rip) LBB1_91: + WORD $0x8944; BYTE $0xca // movl %r9d, %edx + WORD $0x394d; BYTE $0xc8 // cmpq %r9, %r8 + LONG $0x0014840f; WORD $0x0000 // je LBB1_115, $20(%rip) + LONG $0x90909090 // .p2align 4, 0x90 + +LBB1_92: WORD $0x03c6; BYTE $0x30 // movb $48, (%rbx) WORD $0xff48; BYTE $0xc3 // incq %rbx WORD $0xc2ff // incl %edx - WORD $0x3944; BYTE $0xda // cmpl %r11d, %edx - LONG $0xffef8c0f; WORD $0xffff // jl LBB1_91, $-17(%rip) + WORD $0xca39 // cmpl %ecx, %edx + LONG $0xfff08c0f; WORD $0xffff // jl LBB1_92, $-16(%rip) -LBB1_122: - WORD $0x2944; BYTE $0xd3 // subl %r10d, %ebx +LBB1_115: + WORD $0x2944; BYTE $0xf3 // subl %r14d, %ebx -LBB1_123: +LBB1_116: WORD $0xd889 // movl %ebx, %eax LONG $0x08c48348 // addq $8, %rsp BYTE $0x5b // popq %rbx @@ -948,19 +770,24 @@ LBB1_123: WORD $0xf8c5; BYTE $0x77 // vzeroupper BYTE $0xc3 // retq +LBB1_49: + LONG $0x00ff8148; WORD $0x9aca; BYTE $0x3b // cmpq $1000000000, %rdi + LONG $0x00000aba; BYTE $0x00 // movl $10, %edx + LONG $0xfff7e6e9; BYTE $0xff // jmp LBB1_50, $-2074(%rip) + LBB1_1: WORD $0xdb31 // xorl %ebx, %ebx - LONG $0xffffe5e9; BYTE $0xff // jmp LBB1_123, $-27(%rip) + LONG $0xffffd4e9; BYTE $0xff // jmp LBB1_116, $-44(%rip) LBB1_5: - LONG $0xfffbcebe; BYTE $0xff // movl $-1074, %esi + LONG $0xfffbcebb; BYTE $0xff // movl $-1074, %ebx WORD $0x8948; BYTE $0xd7 // movq %rdx, %rdi - LONG $0xfff441e9; BYTE $0xff // jmp LBB1_6, $-3007(%rip) + LONG $0xfff57ae9; BYTE $0xff // jmp LBB1_6, $-2694(%rip) -LBB1_25: +LBB1_26: LONG $0x00ff8148; WORD $0x9aca; BYTE $0x3b // cmpq $1000000000, %rdi LONG $0x00000aba; BYTE $0x00 // movl $10, %edx - LONG $0xfff8dfe9; BYTE $0xff // jmp LBB1_26, $-1825(%rip) + LONG $0xfffa30e9; BYTE $0xff // jmp LBB1_27, $-1488(%rip) WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 _format_integer: @@ -1012,7 +839,7 @@ LBB2_2: WORD $0xcf6b; BYTE $0x64 // imull $100, %edi, %ecx WORD $0xc829 // subl %ecx, %eax LONG $0xd8b70f44 // movzwl %ax, %r11d - LONG $0x400d8d48; WORD $0x00ab; BYTE $0x00 // leaq $43840(%rip), %rcx /* _Digits(%rip) */ + LONG $0x700d8d48; WORD $0x00af; BYTE $0x00 // leaq $44912(%rip), %rcx /* _Digits(%rip) */ LONG $0x04b70f42; BYTE $0x51 // movzwl (%rcx,%r10,2), %eax LONG $0x40894166; BYTE $0xfe // movw %ax, $-2(%r8) LONG $0x04b70f42; BYTE $0x49 // movzwl (%rcx,%r9,2), %eax @@ -1028,7 +855,7 @@ LBB2_2: LBB2_5: LONG $0x1759b941; WORD $0xd1b7 // movl $3518437209, %r9d - LONG $0xf9158d4c; WORD $0x00aa; BYTE $0x00 // leaq $43769(%rip), %r10 /* _Digits(%rip) */ + LONG $0x29158d4c; WORD $0x00af; BYTE $0x00 // leaq $44841(%rip), %r10 /* _Digits(%rip) */ QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90 LBB2_6: @@ -1060,7 +887,7 @@ LBB2_7: WORD $0xc86b; BYTE $0x64 // imull $100, %eax, %ecx WORD $0xca29 // subl %ecx, %edx WORD $0xb70f; BYTE $0xca // movzwl %dx, %ecx - LONG $0x81158d48; WORD $0x00aa; BYTE $0x00 // leaq $43649(%rip), %rdx /* _Digits(%rip) */ + LONG $0xb1158d48; WORD $0x00ae; BYTE $0x00 // leaq $44721(%rip), %rdx /* _Digits(%rip) */ LONG $0x4a0cb70f // movzwl (%rdx,%rcx,2), %ecx LONG $0x4b894166; BYTE $0xfe // movw %cx, $-2(%r11) LONG $0xfec38349 // addq $-2, %r11 @@ -1070,7 +897,7 @@ LBB2_9: WORD $0xfa83; BYTE $0x0a // cmpl $10, %edx LONG $0x0018820f; WORD $0x0000 // jb LBB2_11, $24(%rip) WORD $0xd089 // movl %edx, %eax - LONG $0x600d8d48; WORD $0x00aa; BYTE $0x00 // leaq $43616(%rip), %rcx /* _Digits(%rip) */ + LONG $0x900d8d48; WORD $0x00ae; BYTE $0x00 // leaq $44688(%rip), %rcx /* _Digits(%rip) */ LONG $0x4104b70f // movzwl (%rcx,%rax,2), %eax LONG $0x43894166; BYTE $0xfe // movw %ax, $-2(%r11) WORD $0x894c; BYTE $0xc0 // movq %r8, %rax @@ -1088,100 +915,52 @@ LBB2_11: LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 _i64toa: + WORD $0x8548; BYTE $0xf6 // testq %rsi, %rsi + LONG $0x0005880f; WORD $0x0000 // js LBB3_1, $5(%rip) + LONG $0x000062e9; BYTE $0x00 // jmp _u64toa, $98(%rip) + +LBB3_1: BYTE $0x55 // pushq %rbp WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp - WORD $0x8548; BYTE $0xf6 // testq %rsi, %rsi - LONG $0x00b1880f; WORD $0x0000 // js LBB3_12, $177(%rip) - LONG $0x0ffe8148; WORD $0x0027; BYTE $0x00 // cmpq $9999, %rsi - LONG $0x00b6870f; WORD $0x0000 // ja LBB3_9, $182(%rip) - WORD $0xb70f; BYTE $0xc6 // movzwl %si, %eax - WORD $0xe8c1; BYTE $0x02 // shrl $2, %eax - LONG $0x147bc069; WORD $0x0000 // imull $5243, %eax, %eax - WORD $0xe8c1; BYTE $0x11 // shrl $17, %eax - LONG $0x00148d48 // leaq (%rax,%rax), %rdx - WORD $0xc06b; BYTE $0x64 // imull $100, %eax, %eax - WORD $0xf189 // movl %esi, %ecx - WORD $0xc129 // subl %eax, %ecx - WORD $0xb70f; BYTE $0xc9 // movzwl %cx, %ecx - WORD $0x0148; BYTE $0xc9 // addq %rcx, %rcx - LONG $0x03e8fe81; WORD $0x0000 // cmpl $1000, %esi - LONG $0x0017820f; WORD $0x0000 // jb LBB3_4, $23(%rip) - LONG $0xf3058d48; WORD $0x00a9; BYTE $0x00 // leaq $43507(%rip), %rax /* _Digits(%rip) */ - LONG $0x0204b60f // movzbl (%rdx,%rax), %eax - WORD $0x0788 // movb %al, (%rdi) - LONG $0x000001b8; BYTE $0x00 // movl $1, %eax - LONG $0x00000be9; BYTE $0x00 // jmp LBB3_5, $11(%rip) - -LBB3_4: - WORD $0xc031 // xorl %eax, %eax - WORD $0xfe83; BYTE $0x64 // cmpl $100, %esi - LONG $0x0046820f; WORD $0x0000 // jb LBB3_6, $70(%rip) - -LBB3_5: - WORD $0xb70f; BYTE $0xd2 // movzwl %dx, %edx - LONG $0x01ca8348 // orq $1, %rdx - LONG $0xca358d48; WORD $0x00a9; BYTE $0x00 // leaq $43466(%rip), %rsi /* _Digits(%rip) */ - LONG $0x3214b60f // movzbl (%rdx,%rsi), %edx - WORD $0xc689 // movl %eax, %esi - WORD $0xc0ff // incl %eax - WORD $0x1488; BYTE $0x37 // movb %dl, (%rdi,%rsi) - -LBB3_7: - LONG $0xb8158d48; WORD $0x00a9; BYTE $0x00 // leaq $43448(%rip), %rdx /* _Digits(%rip) */ - LONG $0x1114b60f // movzbl (%rcx,%rdx), %edx - WORD $0xc689 // movl %eax, %esi - WORD $0xc0ff // incl %eax - WORD $0x1488; BYTE $0x37 // movb %dl, (%rdi,%rsi) - -LBB3_8: - WORD $0xb70f; BYTE $0xc9 // movzwl %cx, %ecx - LONG $0x01c98348 // orq $1, %rcx - LONG $0x9f158d48; WORD $0x00a9; BYTE $0x00 // leaq $43423(%rip), %rdx /* _Digits(%rip) */ - LONG $0x110cb60f // movzbl (%rcx,%rdx), %ecx - WORD $0xc289 // movl %eax, %edx + WORD $0x07c6; BYTE $0x2d // movb $45, (%rdi) + WORD $0xff48; BYTE $0xc7 // incq %rdi + WORD $0xf748; BYTE $0xde // negq %rsi + LONG $0x000050e8; BYTE $0x00 // callq _u64toa, $80(%rip) WORD $0xc0ff // incl %eax - WORD $0x0c88; BYTE $0x17 // movb %cl, (%rdi,%rdx) BYTE $0x5d // popq %rbp BYTE $0xc3 // retq + QUAD $0x0000000000000000; LONG $0x00000000 // .p2align 4, 0x00 -LBB3_6: - WORD $0xc031 // xorl %eax, %eax - WORD $0xfe83; BYTE $0x0a // cmpl $10, %esi - LONG $0xffc8830f; WORD $0xffff // jae LBB3_7, $-56(%rip) - LONG $0xffffd5e9; BYTE $0xff // jmp LBB3_8, $-43(%rip) - -LBB3_12: - WORD $0x07c6; BYTE $0x2d // movb $45, (%rdi) - WORD $0xff48; BYTE $0xc7 // incq %rdi - WORD $0xf748; BYTE $0xde // negq %rsi - LONG $0x000044e8; BYTE $0x00 // callq _u64toa, $68(%rip) - WORD $0xc0ff // incl %eax - BYTE $0x5d // popq %rbp - BYTE $0xc3 // retq - -LBB3_9: - LONG $0xfffe8148; WORD $0xf5e0; BYTE $0x05 // cmpq $99999999, %rsi - LONG $0x0006870f; WORD $0x0000 // ja LBB3_10, $6(%rip) - BYTE $0x5d // popq %rbp - LONG $0x00011de9; BYTE $0x00 // jmp _u32toa_medium, $285(%rip) +LCPI4_0: + QUAD $0x00000000d1b71759 // .quad 3518437209 + QUAD $0x00000000d1b71759 // .quad 3518437209 -LBB3_10: - QUAD $0x86f26fc0ffffb848; WORD $0x0023 // movabsq $9999999999999999, %rax - WORD $0x3948; BYTE $0xc6 // cmpq %rax, %rsi - LONG $0x0006870f; WORD $0x0000 // ja LBB3_11, $6(%rip) - BYTE $0x5d // popq %rbp - LONG $0x000244e9; BYTE $0x00 // jmp _u64toa_large_sse2, $580(%rip) +LCPI4_3: + WORD $0x000a // .word 10 + WORD $0x000a // .word 10 + WORD $0x000a // .word 10 + WORD $0x000a // .word 10 + WORD $0x000a // .word 10 + WORD $0x000a // .word 10 + WORD $0x000a // .word 10 + WORD $0x000a // .word 10 -LBB3_11: - BYTE $0x5d // popq %rbp - LONG $0x00038ee9; BYTE $0x00 // jmp _u64toa_xlarge_sse2, $910(%rip) - QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 +LCPI4_4: + QUAD $0x3030303030303030; QUAD $0x3030303030303030 // .space 16, '0000000000000000' + + // .p2align 3, 0x00 +LCPI4_1: + QUAD $0x80003334147b20c5 // .quad -9223315738079846203 +LCPI4_2: + QUAD $0x8000200008000080 // .quad -9223336852348469120 + + // .p2align 4, 0x90 _u64toa: - LONG $0x0ffe8148; WORD $0x0027; BYTE $0x00 // cmpq $9999, %rsi - LONG $0x00a8870f; WORD $0x0000 // ja LBB4_8, $168(%rip) BYTE $0x55 // pushq %rbp WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + LONG $0x0ffe8148; WORD $0x0027; BYTE $0x00 // cmpq $9999, %rsi + LONG $0x00a2870f; WORD $0x0000 // ja LBB4_8, $162(%rip) WORD $0xb70f; BYTE $0xc6 // movzwl %si, %eax WORD $0xe8c1; BYTE $0x02 // shrl $2, %eax LONG $0x147bc069; WORD $0x0000 // imull $5243, %eax, %eax @@ -1190,173 +969,148 @@ _u64toa: WORD $0xc06b; BYTE $0x64 // imull $100, %eax, %eax WORD $0xf189 // movl %esi, %ecx WORD $0xc129 // subl %eax, %ecx - WORD $0xb70f; BYTE $0xc9 // movzwl %cx, %ecx - WORD $0x0148; BYTE $0xc9 // addq %rcx, %rcx + WORD $0xb70f; BYTE $0xc1 // movzwl %cx, %eax + WORD $0x0148; BYTE $0xc0 // addq %rax, %rax LONG $0x03e8fe81; WORD $0x0000 // cmpl $1000, %esi - LONG $0x0017820f; WORD $0x0000 // jb LBB4_3, $23(%rip) - LONG $0xec058d48; WORD $0x00a8; BYTE $0x00 // leaq $43244(%rip), %rax /* _Digits(%rip) */ - LONG $0x0204b60f // movzbl (%rdx,%rax), %eax - WORD $0x0788 // movb %al, (%rdi) - LONG $0x000001b8; BYTE $0x00 // movl $1, %eax + LONG $0x0016820f; WORD $0x0000 // jb LBB4_3, $22(%rip) + LONG $0xbc0d8d48; WORD $0x00ad; BYTE $0x00 // leaq $44476(%rip), %rcx /* _Digits(%rip) */ + WORD $0x0c8a; BYTE $0x0a // movb (%rdx,%rcx), %cl + WORD $0x0f88 // movb %cl, (%rdi) + LONG $0x000001b9; BYTE $0x00 // movl $1, %ecx LONG $0x00000be9; BYTE $0x00 // jmp LBB4_4, $11(%rip) LBB4_3: - WORD $0xc031 // xorl %eax, %eax + WORD $0xc931 // xorl %ecx, %ecx WORD $0xfe83; BYTE $0x64 // cmpl $100, %esi - LONG $0x0046820f; WORD $0x0000 // jb LBB4_5, $70(%rip) + LONG $0x0045820f; WORD $0x0000 // jb LBB4_5, $69(%rip) LBB4_4: WORD $0xb70f; BYTE $0xd2 // movzwl %dx, %edx LONG $0x01ca8348 // orq $1, %rdx - LONG $0xc3358d48; WORD $0x00a8; BYTE $0x00 // leaq $43203(%rip), %rsi /* _Digits(%rip) */ - LONG $0x3214b60f // movzbl (%rdx,%rsi), %edx - WORD $0xc689 // movl %eax, %esi - WORD $0xc0ff // incl %eax + LONG $0x94358d48; WORD $0x00ad; BYTE $0x00 // leaq $44436(%rip), %rsi /* _Digits(%rip) */ + WORD $0x148a; BYTE $0x32 // movb (%rdx,%rsi), %dl + WORD $0xce89 // movl %ecx, %esi + WORD $0xc1ff // incl %ecx WORD $0x1488; BYTE $0x37 // movb %dl, (%rdi,%rsi) LBB4_6: - LONG $0xb1158d48; WORD $0x00a8; BYTE $0x00 // leaq $43185(%rip), %rdx /* _Digits(%rip) */ - LONG $0x1114b60f // movzbl (%rcx,%rdx), %edx - WORD $0xc689 // movl %eax, %esi - WORD $0xc0ff // incl %eax + LONG $0x83158d48; WORD $0x00ad; BYTE $0x00 // leaq $44419(%rip), %rdx /* _Digits(%rip) */ + WORD $0x148a; BYTE $0x10 // movb (%rax,%rdx), %dl + WORD $0xce89 // movl %ecx, %esi + WORD $0xc1ff // incl %ecx WORD $0x1488; BYTE $0x37 // movb %dl, (%rdi,%rsi) LBB4_7: - WORD $0xb70f; BYTE $0xc9 // movzwl %cx, %ecx - LONG $0x01c98348 // orq $1, %rcx - LONG $0x98158d48; WORD $0x00a8; BYTE $0x00 // leaq $43160(%rip), %rdx /* _Digits(%rip) */ - LONG $0x110cb60f // movzbl (%rcx,%rdx), %ecx - WORD $0xc289 // movl %eax, %edx - WORD $0xc0ff // incl %eax - WORD $0x0c88; BYTE $0x17 // movb %cl, (%rdi,%rdx) + WORD $0xb70f; BYTE $0xc0 // movzwl %ax, %eax + LONG $0x01c88348 // orq $1, %rax + LONG $0x6b158d48; WORD $0x00ad; BYTE $0x00 // leaq $44395(%rip), %rdx /* _Digits(%rip) */ + WORD $0x048a; BYTE $0x10 // movb (%rax,%rdx), %al + WORD $0xca89 // movl %ecx, %edx + WORD $0xc1ff // incl %ecx + WORD $0x0488; BYTE $0x17 // movb %al, (%rdi,%rdx) + WORD $0xc889 // movl %ecx, %eax BYTE $0x5d // popq %rbp BYTE $0xc3 // retq LBB4_5: - WORD $0xc031 // xorl %eax, %eax + WORD $0xc931 // xorl %ecx, %ecx WORD $0xfe83; BYTE $0x0a // cmpl $10, %esi LONG $0xffc8830f; WORD $0xffff // jae LBB4_6, $-56(%rip) - LONG $0xffffd5e9; BYTE $0xff // jmp LBB4_7, $-43(%rip) + LONG $0xffffd4e9; BYTE $0xff // jmp LBB4_7, $-44(%rip) LBB4_8: LONG $0xfffe8148; WORD $0xf5e0; BYTE $0x05 // cmpq $99999999, %rsi - LONG $0x0005870f; WORD $0x0000 // ja LBB4_9, $5(%rip) - LONG $0x000029e9; BYTE $0x00 // jmp _u32toa_medium, $41(%rip) - -LBB4_9: - QUAD $0x86f26fc0ffffb848; WORD $0x0023 // movabsq $9999999999999999, %rax - WORD $0x3948; BYTE $0xc6 // cmpq %rax, %rsi - LONG $0x0005870f; WORD $0x0000 // ja LBB4_10, $5(%rip) - LONG $0x000151e9; BYTE $0x00 // jmp _u64toa_large_sse2, $337(%rip) - -LBB4_10: - LONG $0x00029ce9; BYTE $0x00 // jmp _u64toa_xlarge_sse2, $668(%rip) - QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90 - -_u32toa_medium: - BYTE $0x55 // pushq %rbp - WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + LONG $0x011e870f; WORD $0x0000 // ja LBB4_16, $286(%rip) WORD $0xf089 // movl %esi, %eax - LONG $0xb71759b9; BYTE $0xd1 // movl $3518437209, %ecx - LONG $0xc8af0f48 // imulq %rax, %rcx - LONG $0x2de9c148 // shrq $45, %rcx - LONG $0x2710d169; WORD $0x0000 // imull $10000, %ecx, %edx - WORD $0x8941; BYTE $0xf0 // movl %esi, %r8d - WORD $0x2941; BYTE $0xd0 // subl %edx, %r8d - LONG $0x83d06948; WORD $0x1bde; BYTE $0x43 // imulq $1125899907, %rax, %rdx - LONG $0x31eac148 // shrq $49, %rdx - WORD $0xe283; BYTE $0xfe // andl $-2, %edx - LONG $0x1fc16948; WORD $0xeb85; BYTE $0x51 // imulq $1374389535, %rcx, %rax - LONG $0x25e8c148 // shrq $37, %rax + LONG $0xb71759ba; BYTE $0xd1 // movl $3518437209, %edx + LONG $0xd0af0f48 // imulq %rax, %rdx + LONG $0x2deac148 // shrq $45, %rdx + LONG $0x10c26944; WORD $0x0027; BYTE $0x00 // imull $10000, %edx, %r8d + WORD $0xf189 // movl %esi, %ecx + WORD $0x2944; BYTE $0xc1 // subl %r8d, %ecx + LONG $0x83d0694c; WORD $0x1bde; BYTE $0x43 // imulq $1125899907, %rax, %r10 + LONG $0x31eac149 // shrq $49, %r10 + LONG $0xfee28341 // andl $-2, %r10d + WORD $0xb70f; BYTE $0xc2 // movzwl %dx, %eax + WORD $0xe8c1; BYTE $0x02 // shrl $2, %eax + LONG $0x147bc069; WORD $0x0000 // imull $5243, %eax, %eax + WORD $0xe8c1; BYTE $0x11 // shrl $17, %eax + WORD $0xc06b; BYTE $0x64 // imull $100, %eax, %eax + WORD $0xc229 // subl %eax, %edx + LONG $0xcab70f44 // movzwl %dx, %r9d + WORD $0x014d; BYTE $0xc9 // addq %r9, %r9 + WORD $0xb70f; BYTE $0xc1 // movzwl %cx, %eax + WORD $0xe8c1; BYTE $0x02 // shrl $2, %eax + LONG $0x147bc069; WORD $0x0000 // imull $5243, %eax, %eax + WORD $0xe8c1; BYTE $0x11 // shrl $17, %eax + LONG $0x00048d4c // leaq (%rax,%rax), %r8 WORD $0xc06b; BYTE $0x64 // imull $100, %eax, %eax WORD $0xc129 // subl %eax, %ecx - WORD $0x0148; BYTE $0xc9 // addq %rcx, %rcx + LONG $0xd9b70f44 // movzwl %cx, %r11d + WORD $0x014d; BYTE $0xdb // addq %r11, %r11 LONG $0x9680fe81; WORD $0x0098 // cmpl $10000000, %esi - LONG $0x0017820f; WORD $0x0000 // jb LBB5_2, $23(%rip) - LONG $0xed058d48; WORD $0x00a7; BYTE $0x00 // leaq $42989(%rip), %rax /* _Digits(%rip) */ - LONG $0x0204b60f // movzbl (%rdx,%rax), %eax + LONG $0x0017820f; WORD $0x0000 // jb LBB4_11, $23(%rip) + LONG $0xc9058d48; WORD $0x00ac; BYTE $0x00 // leaq $44233(%rip), %rax /* _Digits(%rip) */ + LONG $0x02048a41 // movb (%r10,%rax), %al WORD $0x0788 // movb %al, (%rdi) - LONG $0x000001b8; BYTE $0x00 // movl $1, %eax - LONG $0x00000ee9; BYTE $0x00 // jmp LBB5_3, $14(%rip) + LONG $0x000001b9; BYTE $0x00 // movl $1, %ecx + LONG $0x00000ee9; BYTE $0x00 // jmp LBB4_12, $14(%rip) -LBB5_2: - WORD $0xc031 // xorl %eax, %eax +LBB4_11: + WORD $0xc931 // xorl %ecx, %ecx LONG $0x4240fe81; WORD $0x000f // cmpl $1000000, %esi - LONG $0x0074820f; WORD $0x0000 // jb LBB5_4, $116(%rip) + LONG $0x0076820f; WORD $0x0000 // jb LBB4_13, $118(%rip) -LBB5_3: - WORD $0xd289 // movl %edx, %edx - LONG $0x01ca8348 // orq $1, %rdx - LONG $0xc2358d48; WORD $0x00a7; BYTE $0x00 // leaq $42946(%rip), %rsi /* _Digits(%rip) */ - LONG $0x3214b60f // movzbl (%rdx,%rsi), %edx - WORD $0xc689 // movl %eax, %esi - WORD $0xc0ff // incl %eax - WORD $0x1488; BYTE $0x37 // movb %dl, (%rdi,%rsi) - -LBB5_5: - LONG $0xb0158d48; WORD $0x00a7; BYTE $0x00 // leaq $42928(%rip), %rdx /* _Digits(%rip) */ - LONG $0x1114b60f // movzbl (%rcx,%rdx), %edx - WORD $0xc689 // movl %eax, %esi - WORD $0xc0ff // incl %eax - WORD $0x1488; BYTE $0x37 // movb %dl, (%rdi,%rsi) +LBB4_12: + WORD $0x8944; BYTE $0xd0 // movl %r10d, %eax + LONG $0x01c88348 // orq $1, %rax + LONG $0x9d358d48; WORD $0x00ac; BYTE $0x00 // leaq $44189(%rip), %rsi /* _Digits(%rip) */ + WORD $0x048a; BYTE $0x30 // movb (%rax,%rsi), %al + WORD $0xce89 // movl %ecx, %esi + WORD $0xc1ff // incl %ecx + WORD $0x0488; BYTE $0x37 // movb %al, (%rdi,%rsi) -LBB5_6: - LONG $0xd0b70f41 // movzwl %r8w, %edx - WORD $0xeac1; BYTE $0x02 // shrl $2, %edx - LONG $0x147bd269; WORD $0x0000 // imull $5243, %edx, %edx - WORD $0xeac1; BYTE $0x11 // shrl $17, %edx - WORD $0xf26b; BYTE $0x64 // imull $100, %edx, %esi - WORD $0x2941; BYTE $0xf0 // subl %esi, %r8d - LONG $0xc0b70f45 // movzwl %r8w, %r8d - WORD $0xc989 // movl %ecx, %ecx - LONG $0x01c98348 // orq $1, %rcx - LONG $0x7e0d8d4c; WORD $0x00a7; BYTE $0x00 // leaq $42878(%rip), %r9 /* _Digits(%rip) */ - LONG $0x0cb60f42; BYTE $0x09 // movzbl (%rcx,%r9), %ecx - WORD $0xc689 // movl %eax, %esi - WORD $0x0c88; BYTE $0x37 // movb %cl, (%rdi,%rsi) - LONG $0x0cb70f41; BYTE $0x51 // movzwl (%r9,%rdx,2), %ecx - LONG $0x374c8966; BYTE $0x01 // movw %cx, $1(%rdi,%rsi) - LONG $0x0cb70f43; BYTE $0x41 // movzwl (%r9,%r8,2), %ecx - LONG $0x374c8966; BYTE $0x03 // movw %cx, $3(%rdi,%rsi) - WORD $0xc083; BYTE $0x05 // addl $5, %eax +LBB4_14: + LONG $0x8c058d48; WORD $0x00ac; BYTE $0x00 // leaq $44172(%rip), %rax /* _Digits(%rip) */ + LONG $0x01048a41 // movb (%r9,%rax), %al + WORD $0xce89 // movl %ecx, %esi + WORD $0xc1ff // incl %ecx + WORD $0x0488; BYTE $0x37 // movb %al, (%rdi,%rsi) + +LBB4_15: + LONG $0xc1b70f41 // movzwl %r9w, %eax + LONG $0x01c88348 // orq $1, %rax + LONG $0x72358d48; WORD $0x00ac; BYTE $0x00 // leaq $44146(%rip), %rsi /* _Digits(%rip) */ + WORD $0x048a; BYTE $0x30 // movb (%rax,%rsi), %al + WORD $0xca89 // movl %ecx, %edx + WORD $0x0488; BYTE $0x17 // movb %al, (%rdi,%rdx) + LONG $0x30048a41 // movb (%r8,%rsi), %al + LONG $0x01174488 // movb %al, $1(%rdi,%rdx) + LONG $0xc0b70f41 // movzwl %r8w, %eax + LONG $0x01c88348 // orq $1, %rax + WORD $0x048a; BYTE $0x30 // movb (%rax,%rsi), %al + LONG $0x02174488 // movb %al, $2(%rdi,%rdx) + LONG $0x33048a41 // movb (%r11,%rsi), %al + LONG $0x03174488 // movb %al, $3(%rdi,%rdx) + LONG $0xc3b70f41 // movzwl %r11w, %eax + LONG $0x01c88348 // orq $1, %rax + WORD $0x048a; BYTE $0x30 // movb (%rax,%rsi), %al + WORD $0xc183; BYTE $0x05 // addl $5, %ecx + LONG $0x04174488 // movb %al, $4(%rdi,%rdx) + WORD $0xc889 // movl %ecx, %eax BYTE $0x5d // popq %rbp BYTE $0xc3 // retq -LBB5_4: - WORD $0xc031 // xorl %eax, %eax +LBB4_13: + WORD $0xc931 // xorl %ecx, %ecx LONG $0x86a0fe81; WORD $0x0001 // cmpl $100000, %esi - LONG $0xff96830f; WORD $0xffff // jae LBB5_5, $-106(%rip) - LONG $0xffffa3e9; BYTE $0xff // jmp LBB5_6, $-93(%rip) - QUAD $0x0000000000000000 // .p2align 4, 0x00 - -LCPI6_0: - QUAD $0x00000000d1b71759 // .quad 3518437209 - QUAD $0x00000000d1b71759 // .quad 3518437209 - -LCPI6_3: - WORD $0x000a // .word 10 - WORD $0x000a // .word 10 - WORD $0x000a // .word 10 - WORD $0x000a // .word 10 - WORD $0x000a // .word 10 - WORD $0x000a // .word 10 - WORD $0x000a // .word 10 - WORD $0x000a // .word 10 + LONG $0xff94830f; WORD $0xffff // jae LBB4_14, $-108(%rip) + LONG $0xffffa1e9; BYTE $0xff // jmp LBB4_15, $-95(%rip) -LCPI6_4: - QUAD $0x3030303030303030; QUAD $0x3030303030303030 // .space 16, '0000000000000000' - - // .p2align 3, 0x00 -LCPI6_1: - QUAD $0x80003334147b20c5 // .quad -9223315738079846203 - -LCPI6_2: - QUAD $0x8000200008000080 // .quad -9223336852348469120 - - // .p2align 4, 0x90 -_u64toa_large_sse2: - BYTE $0x55 // pushq %rbp - WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp +LBB4_16: + QUAD $0x86f26fc0ffffb848; WORD $0x0023 // movabsq $9999999999999999, %rax + WORD $0x3948; BYTE $0xc6 // cmpq %rax, %rsi + LONG $0x0105870f; WORD $0x0000 // ja LBB4_18, $261(%rip) QUAD $0x77118461cefdb948; WORD $0xabcc // movabsq $-6067343680855748867, %rcx WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax WORD $0xf748; BYTE $0xe1 // mulq %rcx @@ -1364,7 +1118,7 @@ _u64toa_large_sse2: LONG $0xe100c269; WORD $0x05f5 // imull $100000000, %edx, %eax WORD $0xc629 // subl %eax, %esi LONG $0xc26ef9c5 // vmovd %edx, %xmm0 - QUAD $0xffffff940d6ff9c5 // vmovdqa $-108(%rip), %xmm1 /* LCPI6_0(%rip) */ + QUAD $0xfffffda70d6ff9c5 // vmovdqa $-601(%rip), %xmm1 /* LCPI4_0(%rip) */ LONG $0xd1f4f9c5 // vpmuludq %xmm1, %xmm0, %xmm2 LONG $0xd273e9c5; BYTE $0x2d // vpsrlq $45, %xmm2, %xmm2 LONG $0x002710b8; BYTE $0x00 // movl $10000, %eax @@ -1375,11 +1129,11 @@ _u64toa_large_sse2: LONG $0xf073f9c5; BYTE $0x02 // vpsllq $2, %xmm0, %xmm0 LONG $0xc070fbc5; BYTE $0x50 // vpshuflw $80, %xmm0, %xmm0 LONG $0xc070f9c5; BYTE $0x50 // vpshufd $80, %xmm0, %xmm0 - QUAD $0xffffff8e1512fbc5 // vmovddup $-114(%rip), %xmm2 /* LCPI6_1(%rip) */ + QUAD $0xfffffda11512fbc5 // vmovddup $-607(%rip), %xmm2 /* LCPI4_1(%rip) */ LONG $0xc2e4f9c5 // vpmulhuw %xmm2, %xmm0, %xmm0 - QUAD $0xffffff8a2512fbc5 // vmovddup $-118(%rip), %xmm4 /* LCPI6_2(%rip) */ + QUAD $0xfffffd9d2512fbc5 // vmovddup $-611(%rip), %xmm4 /* LCPI4_2(%rip) */ LONG $0xc4e4f9c5 // vpmulhuw %xmm4, %xmm0, %xmm0 - QUAD $0xffffff562d6ff9c5 // vmovdqa $-170(%rip), %xmm5 /* LCPI6_3(%rip) */ + QUAD $0xfffffd692d6ff9c5 // vmovdqa $-663(%rip), %xmm5 /* LCPI4_3(%rip) */ LONG $0xf5d5f9c5 // vpmullw %xmm5, %xmm0, %xmm6 LONG $0xf673c9c5; BYTE $0x10 // vpsllq $16, %xmm6, %xmm6 LONG $0xc6f9f9c5 // vpsubw %xmm6, %xmm0, %xmm0 @@ -1398,51 +1152,24 @@ _u64toa_large_sse2: LONG $0xf273e9c5; BYTE $0x10 // vpsllq $16, %xmm2, %xmm2 LONG $0xcaf9f1c5 // vpsubw %xmm2, %xmm1, %xmm1 LONG $0xc167f9c5 // vpackuswb %xmm1, %xmm0, %xmm0 - QUAD $0xffffff100dfcf9c5 // vpaddb $-240(%rip), %xmm0, %xmm1 /* LCPI6_4(%rip) */ + QUAD $0xfffffd230dfcf9c5 // vpaddb $-733(%rip), %xmm0, %xmm1 /* LCPI4_4(%rip) */ LONG $0xd2efe9c5 // vpxor %xmm2, %xmm2, %xmm2 LONG $0xc274f9c5 // vpcmpeqb %xmm2, %xmm0, %xmm0 LONG $0xc0d7f9c5 // vpmovmskb %xmm0, %eax - WORD $0xd0f7 // notl %eax LONG $0x0080000d; BYTE $0x00 // orl $32768, %eax - WORD $0xbc0f; BYTE $0xc8 // bsfl %eax, %ecx - LONG $0x000010b8; BYTE $0x00 // movl $16, %eax - WORD $0xc829 // subl %ecx, %eax - LONG $0x04e1c148 // shlq $4, %rcx - LONG $0x68158d48; WORD $0x00cd; BYTE $0x00 // leaq $52584(%rip), %rdx /* _VecShiftShuffles(%rip) */ - LONG $0x0071e2c4; WORD $0x1104 // vpshufb (%rcx,%rdx), %xmm1, %xmm0 + LONG $0xff7fff35; BYTE $0xff // xorl $-32769, %eax + WORD $0xbc0f; BYTE $0xc0 // bsfl %eax, %eax + LONG $0x000010b9; BYTE $0x00 // movl $16, %ecx + WORD $0xc129 // subl %eax, %ecx + LONG $0x04e0c148 // shlq $4, %rax + LONG $0x78158d48; WORD $0x00d2; BYTE $0x00 // leaq $53880(%rip), %rdx /* _VecShiftShuffles(%rip) */ + LONG $0x0071e2c4; WORD $0x1004 // vpshufb (%rax,%rdx), %xmm1, %xmm0 LONG $0x077ffac5 // vmovdqu %xmm0, (%rdi) + WORD $0xc889 // movl %ecx, %eax BYTE $0x5d // popq %rbp BYTE $0xc3 // retq - QUAD $0x0000000000000000; LONG $0x00000000 // .p2align 4, 0x00 -LCPI7_0: - QUAD $0x00000000d1b71759 // .quad 3518437209 - QUAD $0x00000000d1b71759 // .quad 3518437209 - -LCPI7_3: - WORD $0x000a // .word 10 - WORD $0x000a // .word 10 - WORD $0x000a // .word 10 - WORD $0x000a // .word 10 - WORD $0x000a // .word 10 - WORD $0x000a // .word 10 - WORD $0x000a // .word 10 - WORD $0x000a // .word 10 - -LCPI7_4: - QUAD $0x3030303030303030; QUAD $0x3030303030303030 // .space 16, '0000000000000000' - - // .p2align 3, 0x00 -LCPI7_1: - QUAD $0x80003334147b20c5 // .quad -9223315738079846203 - -LCPI7_2: - QUAD $0x8000200008000080 // .quad -9223336852348469120 - - // .p2align 4, 0x90 -_u64toa_xlarge_sse2: - BYTE $0x55 // pushq %rbp - WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp +LBB4_18: QUAD $0x652fb1137857b948; WORD $0x39a5 // movabsq $4153837486827862103, %rcx WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax WORD $0xf748; BYTE $0xe1 // mulq %rcx @@ -1451,29 +1178,31 @@ _u64toa_xlarge_sse2: LONG $0xc2af0f48 // imulq %rdx, %rax WORD $0x2948; BYTE $0xc6 // subq %rax, %rsi WORD $0xfa83; BYTE $0x09 // cmpl $9, %edx - LONG $0x000f870f; WORD $0x0000 // ja LBB7_2, $15(%rip) + LONG $0x000f870f; WORD $0x0000 // ja LBB4_20, $15(%rip) WORD $0xc280; BYTE $0x30 // addb $48, %dl WORD $0x1788 // movb %dl, (%rdi) LONG $0x000001b9; BYTE $0x00 // movl $1, %ecx - LONG $0x0000a7e9; BYTE $0x00 // jmp LBB7_7, $167(%rip) + LONG $0x0000bae9; BYTE $0x00 // jmp LBB4_25, $186(%rip) -LBB7_2: +LBB4_20: WORD $0xfa83; BYTE $0x63 // cmpl $99, %edx - LONG $0x001a870f; WORD $0x0000 // ja LBB7_4, $26(%rip) + LONG $0x001f870f; WORD $0x0000 // ja LBB4_22, $31(%rip) WORD $0xd089 // movl %edx, %eax - LONG $0x5d0d8d48; WORD $0x00a5; BYTE $0x00 // leaq $42333(%rip), %rcx /* _Digits(%rip) */ - LONG $0x4104b70f // movzwl (%rcx,%rax,2), %eax - WORD $0x8966; BYTE $0x07 // movw %ax, (%rdi) + LONG $0xbb0d8d48; WORD $0x00aa; BYTE $0x00 // leaq $43707(%rip), %rcx /* _Digits(%rip) */ + WORD $0x148a; BYTE $0x41 // movb (%rcx,%rax,2), %dl + LONG $0x0141448a // movb $1(%rcx,%rax,2), %al + WORD $0x1788 // movb %dl, (%rdi) + WORD $0x4788; BYTE $0x01 // movb %al, $1(%rdi) LONG $0x000002b9; BYTE $0x00 // movl $2, %ecx - LONG $0x000084e9; BYTE $0x00 // jmp LBB7_7, $132(%rip) + LONG $0x000092e9; BYTE $0x00 // jmp LBB4_25, $146(%rip) -LBB7_4: +LBB4_22: WORD $0xd089 // movl %edx, %eax WORD $0xe8c1; BYTE $0x02 // shrl $2, %eax LONG $0x147bc069; WORD $0x0000 // imull $5243, %eax, %eax WORD $0xe8c1; BYTE $0x11 // shrl $17, %eax LONG $0x03e7fa81; WORD $0x0000 // cmpl $999, %edx - LONG $0x0037870f; WORD $0x0000 // ja LBB7_6, $55(%rip) + LONG $0x003c870f; WORD $0x0000 // ja LBB4_24, $60(%rip) WORD $0xc083; BYTE $0x30 // addl $48, %eax WORD $0x0788 // movb %al, (%rdi) WORD $0xb70f; BYTE $0xc2 // movzwl %dx, %eax @@ -1484,88 +1213,93 @@ LBB7_4: WORD $0xc96b; BYTE $0x64 // imull $100, %ecx, %ecx WORD $0xc829 // subl %ecx, %eax WORD $0xb70f; BYTE $0xc0 // movzwl %ax, %eax - LONG $0x0d0d8d48; WORD $0x00a5; BYTE $0x00 // leaq $42253(%rip), %rcx /* _Digits(%rip) */ - LONG $0x4104b70f // movzwl (%rcx,%rax,2), %eax - LONG $0x01478966 // movw %ax, $1(%rdi) + LONG $0x660d8d48; WORD $0x00aa; BYTE $0x00 // leaq $43622(%rip), %rcx /* _Digits(%rip) */ + WORD $0x148a; BYTE $0x41 // movb (%rcx,%rax,2), %dl + LONG $0x0141448a // movb $1(%rcx,%rax,2), %al + WORD $0x5788; BYTE $0x01 // movb %dl, $1(%rdi) + WORD $0x4788; BYTE $0x02 // movb %al, $2(%rdi) LONG $0x000003b9; BYTE $0x00 // movl $3, %ecx - LONG $0x000033e9; BYTE $0x00 // jmp LBB7_7, $51(%rip) + LONG $0x00003ce9; BYTE $0x00 // jmp LBB4_25, $60(%rip) -LBB7_6: +LBB4_24: WORD $0xc86b; BYTE $0x64 // imull $100, %eax, %ecx WORD $0xca29 // subl %ecx, %edx WORD $0xb70f; BYTE $0xc0 // movzwl %ax, %eax - LONG $0xec0d8d48; WORD $0x00a4; BYTE $0x00 // leaq $42220(%rip), %rcx /* _Digits(%rip) */ - LONG $0x4104b70f // movzwl (%rcx,%rax,2), %eax - WORD $0x8966; BYTE $0x07 // movw %ax, (%rdi) + LONG $0x40058d4c; WORD $0x00aa; BYTE $0x00 // leaq $43584(%rip), %r8 /* _Digits(%rip) */ + LONG $0x400c8a41 // movb (%r8,%rax,2), %cl + LONG $0x40448a41; BYTE $0x01 // movb $1(%r8,%rax,2), %al + WORD $0x0f88 // movb %cl, (%rdi) + WORD $0x4788; BYTE $0x01 // movb %al, $1(%rdi) WORD $0xb70f; BYTE $0xc2 // movzwl %dx, %eax - LONG $0x4114b60f // movzbl (%rcx,%rax,2), %edx + LONG $0x400c8a41 // movb (%r8,%rax,2), %cl WORD $0x0148; BYTE $0xc0 // addq %rax, %rax - WORD $0x5788; BYTE $0x02 // movb %dl, $2(%rdi) + WORD $0x4f88; BYTE $0x02 // movb %cl, $2(%rdi) + WORD $0xc883; BYTE $0x01 // orl $1, %eax WORD $0xb70f; BYTE $0xc0 // movzwl %ax, %eax - LONG $0x0844b60f; BYTE $0x01 // movzbl $1(%rax,%rcx), %eax + LONG $0x00048a42 // movb (%rax,%r8), %al WORD $0x4788; BYTE $0x03 // movb %al, $3(%rdi) LONG $0x000004b9; BYTE $0x00 // movl $4, %ecx -LBB7_7: - QUAD $0x77118461cefdba48; WORD $0xabcc // movabsq $-6067343680855748867, %rdx - WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax - WORD $0xf748; BYTE $0xe2 // mulq %rdx - LONG $0x1aeac148 // shrq $26, %rdx - LONG $0xc26ef9c5 // vmovd %edx, %xmm0 - QUAD $0xfffffeb80d6ff9c5 // vmovdqa $-328(%rip), %xmm1 /* LCPI7_0(%rip) */ - LONG $0xd1f4f9c5 // vpmuludq %xmm1, %xmm0, %xmm2 - LONG $0xd273e9c5; BYTE $0x2d // vpsrlq $45, %xmm2, %xmm2 - LONG $0x002710b8; BYTE $0x00 // movl $10000, %eax - LONG $0x6ef9e1c4; BYTE $0xd8 // vmovq %rax, %xmm3 - LONG $0xe3f4e9c5 // vpmuludq %xmm3, %xmm2, %xmm4 - LONG $0xc4faf9c5 // vpsubd %xmm4, %xmm0, %xmm0 - LONG $0xc061e9c5 // vpunpcklwd %xmm0, %xmm2, %xmm0 - LONG $0xf073f9c5; BYTE $0x02 // vpsllq $2, %xmm0, %xmm0 - LONG $0xc070fbc5; BYTE $0x50 // vpshuflw $80, %xmm0, %xmm0 - LONG $0xc070f9c5; BYTE $0x50 // vpshufd $80, %xmm0, %xmm0 - QUAD $0xfffffeb21512fbc5 // vmovddup $-334(%rip), %xmm2 /* LCPI7_1(%rip) */ - LONG $0xc2e4f9c5 // vpmulhuw %xmm2, %xmm0, %xmm0 - QUAD $0xfffffeae2512fbc5 // vmovddup $-338(%rip), %xmm4 /* LCPI7_2(%rip) */ - LONG $0xc4e4f9c5 // vpmulhuw %xmm4, %xmm0, %xmm0 - QUAD $0xfffffe7a2d6ff9c5 // vmovdqa $-390(%rip), %xmm5 /* LCPI7_3(%rip) */ - LONG $0xf5d5f9c5 // vpmullw %xmm5, %xmm0, %xmm6 - LONG $0xf673c9c5; BYTE $0x10 // vpsllq $16, %xmm6, %xmm6 - LONG $0xc6f9f9c5 // vpsubw %xmm6, %xmm0, %xmm0 - LONG $0xe100c269; WORD $0x05f5 // imull $100000000, %edx, %eax - WORD $0xc629 // subl %eax, %esi - LONG $0xf66ef9c5 // vmovd %esi, %xmm6 - LONG $0xc9f4c9c5 // vpmuludq %xmm1, %xmm6, %xmm1 - LONG $0xd173f1c5; BYTE $0x2d // vpsrlq $45, %xmm1, %xmm1 - LONG $0xdbf4f1c5 // vpmuludq %xmm3, %xmm1, %xmm3 - LONG $0xdbfac9c5 // vpsubd %xmm3, %xmm6, %xmm3 - LONG $0xcb61f1c5 // vpunpcklwd %xmm3, %xmm1, %xmm1 - LONG $0xf173f1c5; BYTE $0x02 // vpsllq $2, %xmm1, %xmm1 - LONG $0xc970fbc5; BYTE $0x50 // vpshuflw $80, %xmm1, %xmm1 - LONG $0xc970f9c5; BYTE $0x50 // vpshufd $80, %xmm1, %xmm1 - LONG $0xcae4f1c5 // vpmulhuw %xmm2, %xmm1, %xmm1 - LONG $0xcce4f1c5 // vpmulhuw %xmm4, %xmm1, %xmm1 - LONG $0xd5d5f1c5 // vpmullw %xmm5, %xmm1, %xmm2 - LONG $0xf273e9c5; BYTE $0x10 // vpsllq $16, %xmm2, %xmm2 - LONG $0xcaf9f1c5 // vpsubw %xmm2, %xmm1, %xmm1 - LONG $0xc167f9c5 // vpackuswb %xmm1, %xmm0, %xmm0 - QUAD $0xfffffe2c05fcf9c5 // vpaddb $-468(%rip), %xmm0, %xmm0 /* LCPI7_4(%rip) */ - WORD $0xc889 // movl %ecx, %eax - LONG $0x047ffac5; BYTE $0x07 // vmovdqu %xmm0, (%rdi,%rax) - WORD $0xc983; BYTE $0x10 // orl $16, %ecx - WORD $0xc889 // movl %ecx, %eax - BYTE $0x5d // popq %rbp - BYTE $0xc3 // retq - QUAD $0x0000000000000000; LONG $0x00000000; WORD $0x0000 // .p2align 4, 0x00 +LBB4_25: + QUAD $0x77118461cefdba48; WORD $0xabcc // movabsq $-6067343680855748867, %rdx + WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax + WORD $0xf748; BYTE $0xe2 // mulq %rdx + LONG $0x1aeac148 // shrq $26, %rdx + LONG $0xc26ef9c5 // vmovd %edx, %xmm0 + QUAD $0xfffffbb30d6ff9c5 // vmovdqa $-1101(%rip), %xmm1 /* LCPI4_0(%rip) */ + LONG $0xd1f4f9c5 // vpmuludq %xmm1, %xmm0, %xmm2 + LONG $0xd273e9c5; BYTE $0x2d // vpsrlq $45, %xmm2, %xmm2 + LONG $0x002710b8; BYTE $0x00 // movl $10000, %eax + LONG $0x6ef9e1c4; BYTE $0xd8 // vmovq %rax, %xmm3 + LONG $0xe3f4e9c5 // vpmuludq %xmm3, %xmm2, %xmm4 + LONG $0xc4faf9c5 // vpsubd %xmm4, %xmm0, %xmm0 + LONG $0xc061e9c5 // vpunpcklwd %xmm0, %xmm2, %xmm0 + LONG $0xf073f9c5; BYTE $0x02 // vpsllq $2, %xmm0, %xmm0 + LONG $0xc070fbc5; BYTE $0x50 // vpshuflw $80, %xmm0, %xmm0 + LONG $0xc070f9c5; BYTE $0x50 // vpshufd $80, %xmm0, %xmm0 + QUAD $0xfffffbad1512fbc5 // vmovddup $-1107(%rip), %xmm2 /* LCPI4_1(%rip) */ + LONG $0xc2e4f9c5 // vpmulhuw %xmm2, %xmm0, %xmm0 + QUAD $0xfffffba92512fbc5 // vmovddup $-1111(%rip), %xmm4 /* LCPI4_2(%rip) */ + LONG $0xc4e4f9c5 // vpmulhuw %xmm4, %xmm0, %xmm0 + QUAD $0xfffffb752d6ff9c5 // vmovdqa $-1163(%rip), %xmm5 /* LCPI4_3(%rip) */ + LONG $0xf5d5f9c5 // vpmullw %xmm5, %xmm0, %xmm6 + LONG $0xf673c9c5; BYTE $0x10 // vpsllq $16, %xmm6, %xmm6 + LONG $0xc6f9f9c5 // vpsubw %xmm6, %xmm0, %xmm0 + LONG $0xe100c269; WORD $0x05f5 // imull $100000000, %edx, %eax + WORD $0xc629 // subl %eax, %esi + LONG $0xf66ef9c5 // vmovd %esi, %xmm6 + LONG $0xc9f4c9c5 // vpmuludq %xmm1, %xmm6, %xmm1 + LONG $0xd173f1c5; BYTE $0x2d // vpsrlq $45, %xmm1, %xmm1 + LONG $0xdbf4f1c5 // vpmuludq %xmm3, %xmm1, %xmm3 + LONG $0xdbfac9c5 // vpsubd %xmm3, %xmm6, %xmm3 + LONG $0xcb61f1c5 // vpunpcklwd %xmm3, %xmm1, %xmm1 + LONG $0xf173f1c5; BYTE $0x02 // vpsllq $2, %xmm1, %xmm1 + LONG $0xc970fbc5; BYTE $0x50 // vpshuflw $80, %xmm1, %xmm1 + LONG $0xc970f9c5; BYTE $0x50 // vpshufd $80, %xmm1, %xmm1 + LONG $0xcae4f1c5 // vpmulhuw %xmm2, %xmm1, %xmm1 + LONG $0xcce4f1c5 // vpmulhuw %xmm4, %xmm1, %xmm1 + LONG $0xd5d5f1c5 // vpmullw %xmm5, %xmm1, %xmm2 + LONG $0xf273e9c5; BYTE $0x10 // vpsllq $16, %xmm2, %xmm2 + LONG $0xcaf9f1c5 // vpsubw %xmm2, %xmm1, %xmm1 + LONG $0xc167f9c5 // vpackuswb %xmm1, %xmm0, %xmm0 + QUAD $0xfffffb2705fcf9c5 // vpaddb $-1241(%rip), %xmm0, %xmm0 /* LCPI4_4(%rip) */ + WORD $0xc889 // movl %ecx, %eax + LONG $0x047ffac5; BYTE $0x07 // vmovdqu %xmm0, (%rdi,%rax) + WORD $0xc983; BYTE $0x10 // orl $16, %ecx + WORD $0xc889 // movl %ecx, %eax + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + QUAD $0x0000000000000000; BYTE $0x00 // .p2align 4, 0x00 + +LCPI5_0: + QUAD $0x2020202020202020; QUAD $0x2020202020202020 // .space 16, ' ' -LCPI8_0: +LCPI5_1: QUAD $0x2222222222222222; QUAD $0x2222222222222222 // .space 16, '""""""""""""""""' -LCPI8_1: +LCPI5_2: QUAD $0x5c5c5c5c5c5c5c5c; QUAD $0x5c5c5c5c5c5c5c5c // .space 16, '\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' -LCPI8_2: - QUAD $0x1f1f1f1f1f1f1f1f; QUAD $0x1f1f1f1f1f1f1f1f // .space 16, '\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f' - // .p2align 4, 0x90 _quote: BYTE $0x55 // pushq %rbp @@ -1575,498 +1309,514 @@ _quote: WORD $0x5541 // pushq %r13 WORD $0x5441 // pushq %r12 BYTE $0x53 // pushq %rbx - LONG $0x20ec8348 // subq $32, %rsp - WORD $0x8949; BYTE $0xcb // movq %rcx, %r11 + BYTE $0x50 // pushq %rax + WORD $0x8949; BYTE $0xcd // movq %rcx, %r13 WORD $0x8949; BYTE $0xd7 // movq %rdx, %r15 - WORD $0x8b4c; BYTE $0x11 // movq (%rcx), %r10 - LONG $0x01c0f641 // testb $1, %r8b WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax - LONG $0x780d8d48; WORD $0x00cb; BYTE $0x00 // leaq $52088(%rip), %rcx /* __SingleQuoteTab(%rip) */ - LONG $0x71258d4c; WORD $0x00db; BYTE $0x00 // leaq $56177(%rip), %r12 /* __DoubleQuoteTab(%rip) */ - LONG $0xe1440f4c // cmoveq %rcx, %r12 + WORD $0x8b4c; BYTE $0x31 // movq (%rcx), %r14 + LONG $0x01c0f641 // testb $1, %r8b + LONG $0xcb0d8d48; WORD $0x00d0; BYTE $0x00 // leaq $53451(%rip), %rcx /* __SingleQuoteTab(%rip) */ + LONG $0xc4058d4c; WORD $0x00e0; BYTE $0x00 // leaq $57540(%rip), %r8 /* __DoubleQuoteTab(%rip) */ + LONG $0xc1440f4c // cmoveq %rcx, %r8 QUAD $0x00000000f50c8d48 // leaq (,%rsi,8), %rcx - WORD $0x3949; BYTE $0xca // cmpq %rcx, %r10 - LONG $0x03ec8d0f; WORD $0x0000 // jge LBB8_56, $1004(%rip) - WORD $0x894d; BYTE $0xfe // movq %r15, %r14 - WORD $0x8949; BYTE $0xf9 // movq %rdi, %r9 + WORD $0x3949; BYTE $0xce // cmpq %rcx, %r14 + LONG $0x04328d0f; WORD $0x0000 // jge LBB5_51, $1074(%rip) + WORD $0x894d; BYTE $0xfb // movq %r15, %r11 + WORD $0x8949; BYTE $0xfa // movq %rdi, %r10 WORD $0x8548; BYTE $0xc0 // testq %rax, %rax - LONG $0x03cc840f; WORD $0x0000 // je LBB8_79, $972(%rip) - LONG $0xc85d894c // movq %r11, $-56(%rbp) - QUAD $0xffffff71056ff9c5 // vmovdqa $-143(%rip), %xmm0 /* LCPI8_0(%rip) */ - QUAD $0xffffff790d6ff9c5 // vmovdqa $-135(%rip), %xmm1 /* LCPI8_1(%rip) */ - QUAD $0xffffff81156ff9c5 // vmovdqa $-127(%rip), %xmm2 /* LCPI8_2(%rip) */ - WORD $0x8948; BYTE $0xf9 // movq %rdi, %rcx + LONG $0x0414840f; WORD $0x0000 // je LBB5_74, $1044(%rip) + QUAD $0xffffff78056ff9c5 // vmovdqa $-136(%rip), %xmm0 /* LCPI5_0(%rip) */ + QUAD $0xffffff800d6ff9c5 // vmovdqa $-128(%rip), %xmm1 /* LCPI5_1(%rip) */ + QUAD $0xffffff88156ff9c5 // vmovdqa $-120(%rip), %xmm2 /* LCPI5_2(%rip) */ + LONG $0xdb76e1c5 // vpcmpeqd %xmm3, %xmm3, %xmm3 + WORD $0x8949; BYTE $0xfa // movq %rdi, %r10 + WORD $0x894d; BYTE $0xfb // movq %r15, %r11 LONG $0xd07d894c // movq %r15, $-48(%rbp) - WORD $0x894d; BYTE $0xfe // movq %r15, %r14 - LONG $0xc065894c // movq %r12, $-64(%rbp) - -LBB8_3: - WORD $0x8949; BYTE $0xc9 // movq %rcx, %r9 - LONG $0x10f88348 // cmpq $16, %rax - WORD $0x9d0f; BYTE $0xc3 // setge %bl - WORD $0x894d; BYTE $0xd4 // movq %r10, %r12 - WORD $0x894d; BYTE $0xf7 // movq %r14, %r15 - WORD $0x8949; BYTE $0xc3 // movq %rax, %r11 - WORD $0x8949; BYTE $0xcd // movq %rcx, %r13 - LONG $0x10fa8349 // cmpq $16, %r10 - LONG $0x00738c0f; WORD $0x0000 // jl LBB8_10, $115(%rip) - LONG $0x10f88348 // cmpq $16, %rax - LONG $0x00698c0f; WORD $0x0000 // jl LBB8_10, $105(%rip) - WORD $0x3145; BYTE $0xff // xorl %r15d, %r15d - WORD $0x8948; BYTE $0xc2 // movq %rax, %rdx - WORD $0x894c; BYTE $0xd1 // movq %r10, %rcx - // .p2align 4, 0x90 -LBB8_6: - LONG $0x6f7a81c4; WORD $0x391c // vmovdqu (%r9,%r15), %xmm3 - LONG $0xe074e1c5 // vpcmpeqb %xmm0, %xmm3, %xmm4 - LONG $0xe974e1c5 // vpcmpeqb %xmm1, %xmm3, %xmm5 - LONG $0xe4ebd1c5 // vpor %xmm4, %xmm5, %xmm4 - LONG $0x7f7a81c4; WORD $0x3e1c // vmovdqu %xmm3, (%r14,%r15) - LONG $0xeadae1c5 // vpminub %xmm2, %xmm3, %xmm5 - LONG $0xdd74e1c5 // vpcmpeqb %xmm5, %xmm3, %xmm3 - LONG $0xdbebd9c5 // vpor %xmm3, %xmm4, %xmm3 - LONG $0xf3d7f9c5 // vpmovmskb %xmm3, %esi - WORD $0xf685 // testl %esi, %esi - LONG $0x012a850f; WORD $0x0000 // jne LBB8_23, $298(%rip) - LONG $0xf05a8d4c // leaq $-16(%rdx), %r11 - LONG $0xf0618d4c // leaq $-16(%rcx), %r12 - LONG $0x10c78349 // addq $16, %r15 - LONG $0x20fa8348 // cmpq $32, %rdx - WORD $0x9d0f; BYTE $0xc3 // setge %bl - LONG $0x00108c0f; WORD $0x0000 // jl LBB8_9, $16(%rip) - WORD $0x894c; BYTE $0xda // movq %r11, %rdx - LONG $0x1ff98348 // cmpq $31, %rcx - WORD $0x894c; BYTE $0xe1 // movq %r12, %rcx - LONG $0xffa78f0f; WORD $0xffff // jg LBB8_6, $-89(%rip) +LBB5_3: + LONG $0x0ff88348 // cmpq $15, %rax + WORD $0x9f0f; BYTE $0xc2 // setg %dl + WORD $0x894d; BYTE $0xf1 // movq %r14, %r9 + WORD $0x894d; BYTE $0xdf // movq %r11, %r15 + WORD $0x8948; BYTE $0xc1 // movq %rax, %rcx + WORD $0x894d; BYTE $0xd4 // movq %r10, %r12 + LONG $0x10fe8349 // cmpq $16, %r14 + LONG $0x008d8c0f; WORD $0x0000 // jl LBB5_9, $141(%rip) + LONG $0x10f88348 // cmpq $16, %rax + LONG $0x00838c0f; WORD $0x0000 // jl LBB5_9, $131(%rip) + WORD $0x894d; BYTE $0xd4 // movq %r10, %r12 + WORD $0x8948; BYTE $0xc6 // movq %rax, %rsi + WORD $0x894d; BYTE $0xdf // movq %r11, %r15 + WORD $0x894c; BYTE $0xf3 // movq %r14, %rbx + LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 -LBB8_9: - LONG $0x392c8d4f // leaq (%r9,%r15), %r13 - WORD $0x014d; BYTE $0xf7 // addq %r14, %r15 +LBB5_6: + LONG $0x6f7ac1c4; WORD $0x2424 // vmovdqu (%r12), %xmm4 + LONG $0xec64f9c5 // vpcmpgtb %xmm4, %xmm0, %xmm5 + LONG $0xf174d9c5 // vpcmpeqb %xmm1, %xmm4, %xmm6 + LONG $0xfa74d9c5 // vpcmpeqb %xmm2, %xmm4, %xmm7 + LONG $0xf6ebc1c5 // vpor %xmm6, %xmm7, %xmm6 + LONG $0x7f7ac1c4; BYTE $0x27 // vmovdqu %xmm4, (%r15) + LONG $0xe364d9c5 // vpcmpgtb %xmm3, %xmm4, %xmm4 + LONG $0xe4dbd1c5 // vpand %xmm4, %xmm5, %xmm4 + LONG $0xe4ebc9c5 // vpor %xmm4, %xmm6, %xmm4 + LONG $0xccd7f9c5 // vpmovmskb %xmm4, %ecx + WORD $0x8566; BYTE $0xc9 // testw %cx, %cx + LONG $0x011a850f; WORD $0x0000 // jne LBB5_18, $282(%rip) + LONG $0x10c48349 // addq $16, %r12 + LONG $0x10c78349 // addq $16, %r15 + LONG $0xf04e8d48 // leaq $-16(%rsi), %rcx + LONG $0xf04b8d4c // leaq $-16(%rbx), %r9 + LONG $0x1ffe8348 // cmpq $31, %rsi + WORD $0x9f0f; BYTE $0xc2 // setg %dl + LONG $0x20fe8348 // cmpq $32, %rsi + LONG $0x001b8c0f; WORD $0x0000 // jl LBB5_9, $27(%rip) + WORD $0x8948; BYTE $0xce // movq %rcx, %rsi + LONG $0x1ffb8348 // cmpq $31, %rbx + WORD $0x894c; BYTE $0xcb // movq %r9, %rbx + LONG $0xff9b8f0f; WORD $0xffff // jg LBB5_6, $-101(%rip) + QUAD $0x9090909090909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 -LBB8_10: - WORD $0xdb84 // testb %bl, %bl - LONG $0x0063840f; WORD $0x0000 // je LBB8_14, $99(%rip) - LONG $0x6f7ac1c4; WORD $0x005d // vmovdqu (%r13), %xmm3 - LONG $0xe074e1c5 // vpcmpeqb %xmm0, %xmm3, %xmm4 - LONG $0xe974e1c5 // vpcmpeqb %xmm1, %xmm3, %xmm5 - LONG $0xe4ebd1c5 // vpor %xmm4, %xmm5, %xmm4 - LONG $0xeadae1c5 // vpminub %xmm2, %xmm3, %xmm5 - LONG $0xed74e1c5 // vpcmpeqb %xmm5, %xmm3, %xmm5 - LONG $0xe5ebd9c5 // vpor %xmm5, %xmm4, %xmm4 - LONG $0xccd7f9c5 // vpmovmskb %xmm4, %ecx +LBB5_9: + WORD $0xd284 // testb %dl, %dl + LONG $0x006a840f; WORD $0x0000 // je LBB5_13, $106(%rip) + WORD $0x894c; BYTE $0xea // movq %r13, %rdx + LONG $0x6f7ac1c4; WORD $0x2424 // vmovdqu (%r12), %xmm4 + LONG $0xec64f9c5 // vpcmpgtb %xmm4, %xmm0, %xmm5 + LONG $0xf174d9c5 // vpcmpeqb %xmm1, %xmm4, %xmm6 + LONG $0xfa74d9c5 // vpcmpeqb %xmm2, %xmm4, %xmm7 + LONG $0xf6ebc1c5 // vpor %xmm6, %xmm7, %xmm6 + LONG $0xfb64d9c5 // vpcmpgtb %xmm3, %xmm4, %xmm7 + LONG $0xefdbd1c5 // vpand %xmm7, %xmm5, %xmm5 + LONG $0xedebc9c5 // vpor %xmm5, %xmm6, %xmm5 + LONG $0xcdd7f9c5 // vpmovmskb %xmm5, %ecx LONG $0x0000c981; WORD $0x0001 // orl $65536, %ecx - LONG $0xd9bc0f44 // bsfl %ecx, %r11d - LONG $0x7ef9e1c4; BYTE $0xd9 // vmovq %xmm3, %rcx - WORD $0x394d; BYTE $0xdc // cmpq %r11, %r12 - LONG $0x00c88d0f; WORD $0x0000 // jge LBB8_24, $200(%rip) - LONG $0x08fc8349 // cmpq $8, %r12 - LONG $0x00fd820f; WORD $0x0000 // jb LBB8_28, $253(%rip) + LONG $0xe9bc0f44 // bsfl %ecx, %r13d + LONG $0x7ef9e1c4; BYTE $0xe1 // vmovq %xmm4, %rcx + WORD $0x394d; BYTE $0xe9 // cmpq %r13, %r9 + LONG $0x00be8d0f; WORD $0x0000 // jge LBB5_19, $190(%rip) + LONG $0x08f98349 // cmpq $8, %r9 + LONG $0x00ff820f; WORD $0x0000 // jb LBB5_22, $255(%rip) WORD $0x8949; BYTE $0x0f // movq %rcx, (%r15) - LONG $0x085d8d4d // leaq $8(%r13), %r11 + LONG $0x246c8d4d; BYTE $0x08 // leaq $8(%r12), %r13 LONG $0x08c78349 // addq $8, %r15 - LONG $0x245c8d49; BYTE $0xf8 // leaq $-8(%r12), %rbx - LONG $0x04fb8348 // cmpq $4, %rbx - LONG $0x00f38d0f; WORD $0x0000 // jge LBB8_29, $243(%rip) - LONG $0x000100e9; BYTE $0x00 // jmp LBB8_30, $256(%rip) - -LBB8_14: - WORD $0x854d; BYTE $0xdb // testq %r11, %r11 - LONG $0x006e8e0f; WORD $0x0000 // jle LBB8_21, $110(%rip) - WORD $0x854d; BYTE $0xe4 // testq %r12, %r12 - LONG $0x00658e0f; WORD $0x0000 // jle LBB8_21, $101(%rip) - LONG $0xb84d894c // movq %r9, $-72(%rbp) - WORD $0x3145; BYTE $0xc9 // xorl %r9d, %r9d - WORD $0xc931 // xorl %ecx, %ecx - QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90 - -LBB8_17: - LONG $0x74b60f43; WORD $0x000d // movzbl (%r13,%r9), %esi - WORD $0x8948; BYTE $0xf3 // movq %rsi, %rbx - LONG $0x04e3c148 // shlq $4, %rbx - LONG $0xec158d48; WORD $0x00c9; BYTE $0x00 // leaq $51692(%rip), %rdx /* __SingleQuoteTab(%rip) */ - LONG $0x133c8348; BYTE $0x00 // cmpq $0, (%rbx,%rdx) - LONG $0x008b850f; WORD $0x0000 // jne LBB8_27, $139(%rip) - LONG $0x0b048d4d // leaq (%r11,%rcx), %r8 - LONG $0x0f348843 // movb %sil, (%r15,%r9) - LONG $0xff598d48 // leaq $-1(%rcx), %rbx - LONG $0x02f88349 // cmpq $2, %r8 - LONG $0x00138c0f; WORD $0x0000 // jl LBB8_20, $19(%rip) - WORD $0x014c; BYTE $0xe1 // addq %r12, %rcx - WORD $0xff49; BYTE $0xc1 // incq %r9 - LONG $0x01f98348 // cmpq $1, %rcx - WORD $0x8948; BYTE $0xd9 // movq %rbx, %rcx - LONG $0xffb88f0f; WORD $0xffff // jg LBB8_17, $-72(%rip) - -LBB8_20: - WORD $0x2949; BYTE $0xdd // subq %rbx, %r13 - WORD $0x0149; BYTE $0xdb // addq %rbx, %r11 - LONG $0xb84d8b4c // movq $-72(%rbp), %r9 + LONG $0xf8718d49 // leaq $-8(%r9), %rsi + LONG $0x04fe8348 // cmpq $4, %rsi + LONG $0x00f58d0f; WORD $0x0000 // jge LBB5_23, $245(%rip) + LONG $0x000103e9; BYTE $0x00 // jmp LBB5_24, $259(%rip) + +LBB5_13: + WORD $0x854d; BYTE $0xc9 // testq %r9, %r9 + LONG $0x01458e0f; WORD $0x0000 // jle LBB5_28, $325(%rip) + WORD $0x8948; BYTE $0xca // movq %rcx, %rdx + WORD $0x8548; BYTE $0xc9 // testq %rcx, %rcx + LONG $0x013c8e0f; WORD $0x0000 // jle LBB5_29, $316(%rip) + QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90 -LBB8_21: - WORD $0x854d; BYTE $0xdb // testq %r11, %r11 - LONG $0xc0658b4c // movq $-64(%rbp), %r12 - LONG $0x0043840f; WORD $0x0000 // je LBB8_26, $67(%rip) - WORD $0xf749; BYTE $0xd5 // notq %r13 - WORD $0x014d; BYTE $0xcd // addq %r9, %r13 - LONG $0x000129e9; BYTE $0x00 // jmp LBB8_41, $297(%rip) - -LBB8_23: - LONG $0xcebc0f66 // bsfw %si, %cx - LONG $0xe9b70f44 // movzwl %cx, %r13d - WORD $0x014d; BYTE $0xfd // addq %r15, %r13 - LONG $0x000115e9; BYTE $0x00 // jmp LBB8_40, $277(%rip) - -LBB8_24: - LONG $0x08fb8341 // cmpl $8, %r11d - LONG $0x00a4820f; WORD $0x0000 // jb LBB8_34, $164(%rip) +LBB5_15: + LONG $0x34b60f41; BYTE $0x24 // movzbl (%r12), %esi + WORD $0x8948; BYTE $0xf2 // movq %rsi, %rdx + LONG $0x04e2c148 // shlq $4, %rdx + LONG $0x2d1d8d48; WORD $0x00cf; BYTE $0x00 // leaq $53037(%rip), %rbx /* __SingleQuoteTab(%rip) */ + LONG $0x1a3c8348; BYTE $0x00 // cmpq $0, (%rdx,%rbx) + LONG $0x0082850f; WORD $0x0000 // jne LBB5_21, $130(%rip) + LONG $0xff518d48 // leaq $-1(%rcx), %rdx + WORD $0xff49; BYTE $0xc4 // incq %r12 + WORD $0x8841; BYTE $0x37 // movb %sil, (%r15) + LONG $0x02f98348 // cmpq $2, %rcx + LONG $0x01018c0f; WORD $0x0000 // jl LBB5_29, $257(%rip) + LONG $0xff718d49 // leaq $-1(%r9), %rsi + WORD $0xff49; BYTE $0xc7 // incq %r15 + WORD $0x8948; BYTE $0xd1 // movq %rdx, %rcx + LONG $0x01f98349 // cmpq $1, %r9 + WORD $0x8949; BYTE $0xf1 // movq %rsi, %r9 + LONG $0xffb78f0f; WORD $0xffff // jg LBB5_15, $-73(%rip) + LONG $0x0000e5e9; BYTE $0x00 // jmp LBB5_29, $229(%rip) + +LBB5_18: + WORD $0xb70f; BYTE $0xc9 // movzwl %cx, %ecx + WORD $0x294d; BYTE $0xd4 // subq %r10, %r12 + LONG $0xc9bc0f44 // bsfl %ecx, %r9d + WORD $0x014d; BYTE $0xe1 // addq %r12, %r9 + WORD $0x854d; BYTE $0xc9 // testq %r9, %r9 + LONG $0xd07d8b4c // movq $-48(%rbp), %r15 + QUAD $0x000300000001bc49; WORD $0x0000 // movabsq $12884901889, %r12 + LONG $0x0166890f; WORD $0x0000 // jns LBB5_37, $358(%rip) + LONG $0x0004abe9; BYTE $0x00 // jmp LBB5_78, $1195(%rip) + +LBB5_19: + LONG $0x08fd8341 // cmpl $8, %r13d + LONG $0x00da820f; WORD $0x0000 // jb LBB5_30, $218(%rip) WORD $0x8949; BYTE $0x0f // movq %rcx, (%r15) - LONG $0x08658d4d // leaq $8(%r13), %r12 + LONG $0x24748d49; BYTE $0x08 // leaq $8(%r12), %rsi LONG $0x08c78349 // addq $8, %r15 - LONG $0xf85b8d49 // leaq $-8(%r11), %rbx - LONG $0x04fb8348 // cmpq $4, %rbx - LONG $0x009b830f; WORD $0x0000 // jae LBB8_35, $155(%rip) - LONG $0x0000a9e9; BYTE $0x00 // jmp LBB8_36, $169(%rip) - -LBB8_26: - WORD $0x294d; BYTE $0xcd // subq %r9, %r13 - LONG $0x0000e9e9; BYTE $0x00 // jmp LBB8_41, $233(%rip) - -LBB8_27: - LONG $0xb84d8b4c // movq $-72(%rbp), %r9 - WORD $0x294d; BYTE $0xcd // subq %r9, %r13 - WORD $0x2949; BYTE $0xcd // subq %rcx, %r13 - LONG $0x0000d6e9; BYTE $0x00 // jmp LBB8_40, $214(%rip) - -LBB8_28: - WORD $0x894d; BYTE $0xeb // movq %r13, %r11 - WORD $0x894c; BYTE $0xe3 // movq %r12, %rbx + LONG $0xf85d8d49 // leaq $-8(%r13), %rbx LONG $0x04fb8348 // cmpq $4, %rbx - LONG $0x00128c0f; WORD $0x0000 // jl LBB8_30, $18(%rip) - -LBB8_29: - WORD $0x8b41; BYTE $0x0b // movl (%r11), %ecx + LONG $0x00d08d0f; WORD $0x0000 // jge LBB5_31, $208(%rip) + LONG $0x0000dce9; BYTE $0x00 // jmp LBB5_32, $220(%rip) + +LBB5_21: + WORD $0x294d; BYTE $0xd4 // subq %r10, %r12 + WORD $0x894d; BYTE $0xe1 // movq %r12, %r9 + WORD $0x854d; BYTE $0xc9 // testq %r9, %r9 + LONG $0xd07d8b4c // movq $-48(%rbp), %r15 + QUAD $0x000300000001bc49; WORD $0x0000 // movabsq $12884901889, %r12 + LONG $0x011b890f; WORD $0x0000 // jns LBB5_37, $283(%rip) + LONG $0x000460e9; BYTE $0x00 // jmp LBB5_78, $1120(%rip) + +LBB5_22: + WORD $0x894d; BYTE $0xe5 // movq %r12, %r13 + WORD $0x894c; BYTE $0xce // movq %r9, %rsi + LONG $0x04fe8348 // cmpq $4, %rsi + LONG $0x00138c0f; WORD $0x0000 // jl LBB5_24, $19(%rip) + +LBB5_23: + LONG $0x004d8b41 // movl (%r13), %ecx WORD $0x8941; BYTE $0x0f // movl %ecx, (%r15) - LONG $0x04c38349 // addq $4, %r11 + LONG $0x04c58349 // addq $4, %r13 LONG $0x04c78349 // addq $4, %r15 - LONG $0xfcc38348 // addq $-4, %rbx + LONG $0xfcc68348 // addq $-4, %rsi -LBB8_30: - LONG $0x02fb8348 // cmpq $2, %rbx - LONG $0x0022820f; WORD $0x0000 // jb LBB8_31, $34(%rip) - LONG $0x0bb70f41 // movzwl (%r11), %ecx +LBB5_24: + LONG $0x02fe8348 // cmpq $2, %rsi + LONG $0x0023820f; WORD $0x0000 // jb LBB5_25, $35(%rip) + LONG $0x4db70f41; BYTE $0x00 // movzwl (%r13), %ecx LONG $0x0f894166 // movw %cx, (%r15) - LONG $0x02c38349 // addq $2, %r11 + LONG $0x02c58349 // addq $2, %r13 LONG $0x02c78349 // addq $2, %r15 - LONG $0xfec38348 // addq $-2, %rbx - WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx - LONG $0x000e850f; WORD $0x0000 // jne LBB8_32, $14(%rip) - LONG $0x000010e9; BYTE $0x00 // jmp LBB8_33, $16(%rip) + LONG $0xfec68348 // addq $-2, %rsi + WORD $0x8548; BYTE $0xf6 // testq %rsi, %rsi + LONG $0x000e850f; WORD $0x0000 // jne LBB5_26, $14(%rip) + LONG $0x000010e9; BYTE $0x00 // jmp LBB5_27, $16(%rip) -LBB8_31: - WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx - LONG $0x0007840f; WORD $0x0000 // je LBB8_33, $7(%rip) +LBB5_25: + WORD $0x8548; BYTE $0xf6 // testq %rsi, %rsi + LONG $0x0007840f; WORD $0x0000 // je LBB5_27, $7(%rip) -LBB8_32: - LONG $0x0bb60f41 // movzbl (%r11), %ecx +LBB5_26: + LONG $0x004d8a41 // movb (%r13), %cl WORD $0x8841; BYTE $0x0f // movb %cl, (%r15) -LBB8_33: - WORD $0x014d; BYTE $0xec // addq %r13, %r12 - WORD $0xf749; BYTE $0xd4 // notq %r12 - WORD $0x014d; BYTE $0xcc // addq %r9, %r12 - WORD $0x894d; BYTE $0xe5 // movq %r12, %r13 - LONG $0x000067e9; BYTE $0x00 // jmp LBB8_40, $103(%rip) +LBB5_27: + WORD $0x294d; BYTE $0xd1 // subq %r10, %r9 + WORD $0x014d; BYTE $0xe1 // addq %r12, %r9 + WORD $0xf749; BYTE $0xd1 // notq %r9 + LONG $0x00008ee9; BYTE $0x00 // jmp LBB5_36, $142(%rip) -LBB8_34: - WORD $0x894d; BYTE $0xec // movq %r13, %r12 - WORD $0x894c; BYTE $0xdb // movq %r11, %rbx +LBB5_28: + WORD $0x8948; BYTE $0xca // movq %rcx, %rdx + +LBB5_29: + WORD $0x294d; BYTE $0xd4 // subq %r10, %r12 + WORD $0xf748; BYTE $0xda // negq %rdx + WORD $0x194d; BYTE $0xc9 // sbbq %r9, %r9 + WORD $0x314d; BYTE $0xe1 // xorq %r12, %r9 + WORD $0x854d; BYTE $0xc9 // testq %r9, %r9 + LONG $0xd07d8b4c // movq $-48(%rbp), %r15 + QUAD $0x000300000001bc49; WORD $0x0000 // movabsq $12884901889, %r12 + LONG $0x0082890f; WORD $0x0000 // jns LBB5_37, $130(%rip) + LONG $0x0003c7e9; BYTE $0x00 // jmp LBB5_78, $967(%rip) + +LBB5_30: + WORD $0x894c; BYTE $0xe6 // movq %r12, %rsi + WORD $0x894c; BYTE $0xeb // movq %r13, %rbx LONG $0x04fb8348 // cmpq $4, %rbx - LONG $0x0013820f; WORD $0x0000 // jb LBB8_36, $19(%rip) + LONG $0x00118c0f; WORD $0x0000 // jl LBB5_32, $17(%rip) -LBB8_35: - LONG $0x240c8b41 // movl (%r12), %ecx +LBB5_31: + WORD $0x0e8b // movl (%rsi), %ecx WORD $0x8941; BYTE $0x0f // movl %ecx, (%r15) - LONG $0x04c48349 // addq $4, %r12 + LONG $0x04c68348 // addq $4, %rsi LONG $0x04c78349 // addq $4, %r15 LONG $0xfcc38348 // addq $-4, %rbx -LBB8_36: +LBB5_32: LONG $0x02fb8348 // cmpq $2, %rbx - LONG $0x0023820f; WORD $0x0000 // jb LBB8_37, $35(%rip) - LONG $0x0cb70f41; BYTE $0x24 // movzwl (%r12), %ecx + LONG $0x0021820f; WORD $0x0000 // jb LBB5_33, $33(%rip) + WORD $0xb70f; BYTE $0x0e // movzwl (%rsi), %ecx LONG $0x0f894166 // movw %cx, (%r15) - LONG $0x02c48349 // addq $2, %r12 + LONG $0x02c68348 // addq $2, %rsi LONG $0x02c78349 // addq $2, %r15 LONG $0xfec38348 // addq $-2, %rbx WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx - LONG $0x000e850f; WORD $0x0000 // jne LBB8_38, $14(%rip) - LONG $0x000011e9; BYTE $0x00 // jmp LBB8_39, $17(%rip) + LONG $0x000e850f; WORD $0x0000 // jne LBB5_34, $14(%rip) + LONG $0x00000ee9; BYTE $0x00 // jmp LBB5_35, $14(%rip) -LBB8_37: +LBB5_33: WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx - LONG $0x0008840f; WORD $0x0000 // je LBB8_39, $8(%rip) - -LBB8_38: - LONG $0x0cb60f41; BYTE $0x24 // movzbl (%r12), %ecx - WORD $0x8841; BYTE $0x0f // movb %cl, (%r15) + LONG $0x0005840f; WORD $0x0000 // je LBB5_35, $5(%rip) -LBB8_39: - WORD $0x294d; BYTE $0xcd // subq %r9, %r13 - WORD $0x014d; BYTE $0xdd // addq %r11, %r13 - -LBB8_40: - LONG $0xc0658b4c // movq $-64(%rbp), %r12 +LBB5_34: + WORD $0x0e8a // movb (%rsi), %cl + WORD $0x8841; BYTE $0x0f // movb %cl, (%r15) -LBB8_41: - QUAD $0x000300000001bb49; WORD $0x0000 // movabsq $12884901889, %r11 - WORD $0x854d; BYTE $0xed // testq %r13, %r13 - LONG $0x0313880f; WORD $0x0000 // js LBB8_82, $787(%rip) - WORD $0x014d; BYTE $0xee // addq %r13, %r14 - WORD $0x394c; BYTE $0xe8 // cmpq %r13, %rax - LONG $0x00c2840f; WORD $0x0000 // je LBB8_78, $194(%rip) - WORD $0x294d; BYTE $0xea // subq %r13, %r10 - LONG $0x000015e9; BYTE $0x00 // jmp LBB8_45, $21(%rip) - LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 +LBB5_35: + WORD $0x294d; BYTE $0xd4 // subq %r10, %r12 + WORD $0x014d; BYTE $0xec // addq %r13, %r12 + WORD $0x894d; BYTE $0xe1 // movq %r12, %r9 + +LBB5_36: + WORD $0x8949; BYTE $0xd5 // movq %rdx, %r13 + WORD $0x854d; BYTE $0xc9 // testq %r9, %r9 + LONG $0xd07d8b4c // movq $-48(%rbp), %r15 + QUAD $0x000300000001bc49; WORD $0x0000 // movabsq $12884901889, %r12 + LONG $0x034a880f; WORD $0x0000 // js LBB5_78, $842(%rip) + +LBB5_37: + WORD $0x014d; BYTE $0xca // addq %r9, %r10 + WORD $0x014d; BYTE $0xcb // addq %r9, %r11 + WORD $0x394c; BYTE $0xc8 // cmpq %r9, %rax + LONG $0x00cd840f; WORD $0x0000 // je LBB5_74, $205(%rip) + WORD $0x294d; BYTE $0xce // subq %r9, %r14 + WORD $0x2949; BYTE $0xc1 // subq %rax, %r9 + LONG $0x00001de9; BYTE $0x00 // jmp LBB5_40, $29(%rip) + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 -LBB8_44: - WORD $0x0149; BYTE $0xf6 // addq %rsi, %r14 - WORD $0xff49; BYTE $0xc5 // incq %r13 - WORD $0x394c; BYTE $0xe8 // cmpq %r13, %rax - LONG $0x00a5840f; WORD $0x0000 // je LBB8_78, $165(%rip) - -LBB8_45: - LONG $0x0cb60f43; BYTE $0x29 // movzbl (%r9,%r13), %ecx - LONG $0x04e1c148 // shlq $4, %rcx - LONG $0x0c148b41 // movl (%r12,%rcx), %edx - WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx - LONG $0x0082840f; WORD $0x0000 // je LBB8_53, $130(%rip) - WORD $0x6348; BYTE $0xf2 // movslq %edx, %rsi - WORD $0x2949; BYTE $0xf2 // subq %rsi, %r10 - LONG $0x02a28c0f; WORD $0x0000 // jl LBB8_80, $674(%rip) - LONG $0x20e2c148 // shlq $32, %rdx - LONG $0x0c1c8d49 // leaq (%r12,%rcx), %rbx - LONG $0x08c38348 // addq $8, %rbx - WORD $0x394c; BYTE $0xda // cmpq %r11, %rdx - LONG $0x002a8c0f; WORD $0x0000 // jl LBB8_49, $42(%rip) - WORD $0x0b8b // movl (%rbx), %ecx - WORD $0x8941; BYTE $0x0e // movl %ecx, (%r14) - LONG $0x04c38348 // addq $4, %rbx - LONG $0x04468d4d // leaq $4(%r14), %r8 - LONG $0xfc4e8d48 // leaq $-4(%rsi), %rcx - LONG $0x02f98348 // cmpq $2, %rcx - LONG $0x001f830f; WORD $0x0000 // jae LBB8_50, $31(%rip) - LONG $0x00002de9; BYTE $0x00 // jmp LBB8_51, $45(%rip) - QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90 +LBB5_39: + WORD $0xff49; BYTE $0xc2 // incq %r10 + WORD $0x0149; BYTE $0xc3 // addq %rax, %r11 + WORD $0xff49; BYTE $0xc1 // incq %r9 + LONG $0x00a5840f; WORD $0x0000 // je LBB5_74, $165(%rip) + +LBB5_40: + LONG $0x0ab60f41 // movzbl (%r10), %ecx + LONG $0x04e1c148 // shlq $4, %rcx + LONG $0x08348b49 // movq (%r8,%rcx), %rsi + WORD $0xf685 // testl %esi, %esi + LONG $0x0082840f; WORD $0x0000 // je LBB5_48, $130(%rip) + WORD $0x6348; BYTE $0xc6 // movslq %esi, %rax + WORD $0x2949; BYTE $0xc6 // subq %rax, %r14 + LONG $0x02d48c0f; WORD $0x0000 // jl LBB5_75, $724(%rip) + LONG $0x20e6c148 // shlq $32, %rsi + LONG $0x08548d49; BYTE $0x08 // leaq $8(%r8,%rcx), %rdx + WORD $0x394c; BYTE $0xe6 // cmpq %r12, %rsi + LONG $0x002f8c0f; WORD $0x0000 // jl LBB5_44, $47(%rip) + WORD $0x128b // movl (%rdx), %edx + WORD $0x8941; BYTE $0x13 // movl %edx, (%r11) + LONG $0x08548d49; BYTE $0x0c // leaq $12(%r8,%rcx), %rdx + LONG $0x044b8d49 // leaq $4(%r11), %rcx + LONG $0xfc708d48 // leaq $-4(%rax), %rsi + LONG $0x02fe8348 // cmpq $2, %rsi + LONG $0x0023830f; WORD $0x0000 // jae LBB5_45, $35(%rip) + LONG $0x000030e9; BYTE $0x00 // jmp LBB5_46, $48(%rip) + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 -LBB8_49: - WORD $0x894d; BYTE $0xf0 // movq %r14, %r8 - WORD $0x8948; BYTE $0xf1 // movq %rsi, %rcx - LONG $0x02f98348 // cmpq $2, %rcx - LONG $0x0013820f; WORD $0x0000 // jb LBB8_51, $19(%rip) +LBB5_44: + WORD $0x894c; BYTE $0xd9 // movq %r11, %rcx + WORD $0x8948; BYTE $0xc6 // movq %rax, %rsi + LONG $0x02fe8348 // cmpq $2, %rsi + LONG $0x0012820f; WORD $0x0000 // jb LBB5_46, $18(%rip) -LBB8_50: - WORD $0xb70f; BYTE $0x13 // movzwl (%rbx), %edx - LONG $0x10894166 // movw %dx, (%r8) - LONG $0x02c38348 // addq $2, %rbx - LONG $0x02c08349 // addq $2, %r8 - LONG $0xfec18348 // addq $-2, %rcx +LBB5_45: + WORD $0xb70f; BYTE $0x1a // movzwl (%rdx), %ebx + WORD $0x8966; BYTE $0x19 // movw %bx, (%rcx) + LONG $0x02c28348 // addq $2, %rdx + LONG $0x02c18348 // addq $2, %rcx + LONG $0xfec68348 // addq $-2, %rsi -LBB8_51: - WORD $0x8548; BYTE $0xc9 // testq %rcx, %rcx - LONG $0xff64840f; WORD $0xffff // je LBB8_44, $-156(%rip) - WORD $0xb60f; BYTE $0x0b // movzbl (%rbx), %ecx - WORD $0x8841; BYTE $0x08 // movb %cl, (%r8) - LONG $0xffff59e9; BYTE $0xff // jmp LBB8_44, $-167(%rip) - -LBB8_53: - LONG $0x290c8d4b // leaq (%r9,%r13), %rcx - WORD $0x294c; BYTE $0xe8 // subq %r13, %rax - LONG $0xfc69850f; WORD $0xffff // jne LBB8_3, $-919(%rip) - -LBB8_78: - WORD $0x014d; BYTE $0xe9 // addq %r13, %r9 - LONG $0xc85d8b4c // movq $-56(%rbp), %r11 - LONG $0xd07d8b4c // movq $-48(%rbp), %r15 - -LBB8_79: - WORD $0x294d; BYTE $0xfe // subq %r15, %r14 - WORD $0x894d; BYTE $0x33 // movq %r14, (%r11) - WORD $0x2949; BYTE $0xf9 // subq %rdi, %r9 - WORD $0x894c; BYTE $0xc8 // movq %r9, %rax - LONG $0x00021ae9; BYTE $0x00 // jmp LBB8_81, $538(%rip) +LBB5_46: + WORD $0x8548; BYTE $0xf6 // testq %rsi, %rsi + LONG $0xff65840f; WORD $0xffff // je LBB5_39, $-155(%rip) + WORD $0xb60f; BYTE $0x12 // movzbl (%rdx), %edx + WORD $0x1188 // movb %dl, (%rcx) + LONG $0xffff5be9; BYTE $0xff // jmp LBB5_39, $-165(%rip) -LBB8_56: - QUAD $0xfffffb98056ff9c5 // vmovdqa $-1128(%rip), %xmm0 /* LCPI8_0(%rip) */ - QUAD $0xfffffba00d6ff9c5 // vmovdqa $-1120(%rip), %xmm1 /* LCPI8_1(%rip) */ - QUAD $0xfffffba8156ff9c5 // vmovdqa $-1112(%rip), %xmm2 /* LCPI8_2(%rip) */ - LONG $0x510d8d4c; WORD $0x00e7; BYTE $0x00 // leaq $59217(%rip), %r9 /* __EscTab(%rip) */ - WORD $0x894c; BYTE $0xfe // movq %r15, %rsi - WORD $0x8948; BYTE $0xc3 // movq %rax, %rbx +LBB5_48: + WORD $0x894c; BYTE $0xc8 // movq %r9, %rax + WORD $0xf748; BYTE $0xd8 // negq %rax + WORD $0x854d; BYTE $0xc9 // testq %r9, %r9 + LONG $0xfc12850f; WORD $0xffff // jne LBB5_3, $-1006(%rip) + +LBB5_74: + WORD $0x294d; BYTE $0xfb // subq %r15, %r11 + LONG $0x005d894d // movq %r11, (%r13) + WORD $0x2949; BYTE $0xfa // subq %rdi, %r10 + LONG $0x00024de9; BYTE $0x00 // jmp LBB5_76, $589(%rip) + +LBB5_51: + LONG $0x760d8d4c; WORD $0x00ec; BYTE $0x00 // leaq $60534(%rip), %r9 /* __EscTab(%rip) */ + QUAD $0xfffffb4e056ff9c5 // vmovdqa $-1202(%rip), %xmm0 /* LCPI5_0(%rip) */ + QUAD $0xfffffb560d6ff9c5 // vmovdqa $-1194(%rip), %xmm1 /* LCPI5_1(%rip) */ + QUAD $0xfffffb5e156ff9c5 // vmovdqa $-1186(%rip), %xmm2 /* LCPI5_2(%rip) */ + LONG $0xdb76e1c5 // vpcmpeqd %xmm3, %xmm3, %xmm3 + WORD $0x894c; BYTE $0xfb // movq %r15, %rbx + WORD $0x8949; BYTE $0xc2 // movq %rax, %r10 -LBB8_57: - LONG $0x10fb8348 // cmpq $16, %rbx - LONG $0x00438c0f; WORD $0x0000 // jl LBB8_60, $67(%rip) - BYTE $0x90 // .p2align 4, 0x90 +LBB5_52: + LONG $0x10fa8349 // cmpq $16, %r10 + LONG $0x005d8c0f; WORD $0x0000 // jl LBB5_57, $93(%rip) + LONG $0x000010b9; BYTE $0x00 // movl $16, %ecx + WORD $0xd231 // xorl %edx, %edx + WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 -LBB8_58: - LONG $0x1f6ffac5 // vmovdqu (%rdi), %xmm3 - LONG $0xe074e1c5 // vpcmpeqb %xmm0, %xmm3, %xmm4 - LONG $0xe974e1c5 // vpcmpeqb %xmm1, %xmm3, %xmm5 - LONG $0xe4ebd1c5 // vpor %xmm4, %xmm5, %xmm4 - LONG $0x1e7ffac5 // vmovdqu %xmm3, (%rsi) - LONG $0xeadae1c5 // vpminub %xmm2, %xmm3, %xmm5 - LONG $0xdd74e1c5 // vpcmpeqb %xmm5, %xmm3, %xmm3 - LONG $0xdbebd9c5 // vpor %xmm3, %xmm4, %xmm3 - LONG $0xcbd7f9c5 // vpmovmskb %xmm3, %ecx - WORD $0xc985 // testl %ecx, %ecx - LONG $0x0120850f; WORD $0x0000 // jne LBB8_70, $288(%rip) - LONG $0x10c78348 // addq $16, %rdi - LONG $0x10c68348 // addq $16, %rsi - LONG $0xf0c38348 // addq $-16, %rbx - LONG $0x10fb8348 // cmpq $16, %rbx - LONG $0xffbe830f; WORD $0xffff // jae LBB8_58, $-66(%rip) - -LBB8_60: - LONG $0x08fb8348 // cmpq $8, %rbx - LONG $0x007b8c0f; WORD $0x0000 // jl LBB8_64, $123(%rip) +LBB5_54: + LONG $0x246ffac5; BYTE $0x17 // vmovdqu (%rdi,%rdx), %xmm4 + LONG $0xec64f9c5 // vpcmpgtb %xmm4, %xmm0, %xmm5 + LONG $0xf174d9c5 // vpcmpeqb %xmm1, %xmm4, %xmm6 + LONG $0xfa74d9c5 // vpcmpeqb %xmm2, %xmm4, %xmm7 + LONG $0xf6ebc1c5 // vpor %xmm6, %xmm7, %xmm6 + LONG $0x247ffac5; BYTE $0x13 // vmovdqu %xmm4, (%rbx,%rdx) + LONG $0xe364d9c5 // vpcmpgtb %xmm3, %xmm4, %xmm4 + LONG $0xe4dbd1c5 // vpand %xmm4, %xmm5, %xmm4 + LONG $0xe4ebc9c5 // vpor %xmm4, %xmm6, %xmm4 + LONG $0xf4d7f9c5 // vpmovmskb %xmm4, %esi + WORD $0x8566; BYTE $0xf6 // testw %si, %si + LONG $0x0139850f; WORD $0x0000 // jne LBB5_67, $313(%rip) + LONG $0x10c28348 // addq $16, %rdx + LONG $0x0a748d49; BYTE $0xf0 // leaq $-16(%r10,%rcx), %rsi + LONG $0xf0c18348 // addq $-16, %rcx + LONG $0x1ffe8348 // cmpq $31, %rsi + LONG $0xffb68f0f; WORD $0xffff // jg LBB5_54, $-74(%rip) + WORD $0x0148; BYTE $0xd7 // addq %rdx, %rdi + WORD $0x2949; BYTE $0xd2 // subq %rdx, %r10 + WORD $0x0148; BYTE $0xd3 // addq %rdx, %rbx + +LBB5_57: + LONG $0x08fa8349 // cmpq $8, %r10 + LONG $0x00858c0f; WORD $0x0000 // jl LBB5_61, $133(%rip) WORD $0xb60f; BYTE $0x0f // movzbl (%rdi), %ecx + LONG $0x0cb60f42; BYTE $0x09 // movzbl (%rcx,%r9), %ecx LONG $0x0157b60f // movzbl $1(%rdi), %edx LONG $0x14b60f42; BYTE $0x0a // movzbl (%rdx,%r9), %edx - WORD $0xd200 // addb %dl, %dl - LONG $0x09140a42 // orb (%rcx,%r9), %dl + WORD $0xd201 // addl %edx, %edx + WORD $0xca09 // orl %ecx, %edx LONG $0x024fb60f // movzbl $2(%rdi), %ecx + LONG $0x34b60f42; BYTE $0x09 // movzbl (%rcx,%r9), %esi + WORD $0xe6c1; BYTE $0x02 // shll $2, %esi + LONG $0x034fb60f // movzbl $3(%rdi), %ecx LONG $0x0cb60f42; BYTE $0x09 // movzbl (%rcx,%r9), %ecx - WORD $0xe1c0; BYTE $0x02 // shlb $2, %cl - WORD $0xd108 // orb %dl, %cl - LONG $0x0357b60f // movzbl $3(%rdi), %edx - LONG $0x14b60f42; BYTE $0x0a // movzbl (%rdx,%r9), %edx - WORD $0xe2c0; BYTE $0x03 // shlb $3, %dl - WORD $0xca08 // orb %cl, %dl - WORD $0x8b48; BYTE $0x0f // movq (%rdi), %rcx - WORD $0x8948; BYTE $0x0e // movq %rcx, (%rsi) - LONG $0x0117850f; WORD $0x0000 // jne LBB8_75, $279(%rip) + WORD $0xe1c1; BYTE $0x03 // shll $3, %ecx + WORD $0xf109 // orl %esi, %ecx + WORD $0xd109 // orl %edx, %ecx + WORD $0x8b48; BYTE $0x17 // movq (%rdi), %rdx + WORD $0x8948; BYTE $0x13 // movq %rdx, (%rbx) + WORD $0xc984 // testb %cl, %cl + LONG $0x0131850f; WORD $0x0000 // jne LBB5_71, $305(%rip) LONG $0x044fb60f // movzbl $4(%rdi), %ecx + LONG $0x0cb60f42; BYTE $0x09 // movzbl (%rcx,%r9), %ecx LONG $0x0557b60f // movzbl $5(%rdi), %edx LONG $0x14b60f42; BYTE $0x0a // movzbl (%rdx,%r9), %edx - WORD $0xd200 // addb %dl, %dl - LONG $0x09140a42 // orb (%rcx,%r9), %dl + WORD $0xd201 // addl %edx, %edx + WORD $0xca09 // orl %ecx, %edx LONG $0x064fb60f // movzbl $6(%rdi), %ecx + LONG $0x34b60f42; BYTE $0x09 // movzbl (%rcx,%r9), %esi + WORD $0xe6c1; BYTE $0x02 // shll $2, %esi + LONG $0x074fb60f // movzbl $7(%rdi), %ecx LONG $0x0cb60f42; BYTE $0x09 // movzbl (%rcx,%r9), %ecx - WORD $0xe1c0; BYTE $0x02 // shlb $2, %cl - WORD $0xd108 // orb %dl, %cl - LONG $0x0757b60f // movzbl $7(%rdi), %edx - LONG $0x14b60f42; BYTE $0x0a // movzbl (%rdx,%r9), %edx - WORD $0xe2c0; BYTE $0x03 // shlb $3, %dl - WORD $0xca08 // orb %cl, %dl - LONG $0x00ed850f; WORD $0x0000 // jne LBB8_76, $237(%rip) - LONG $0x08c68348 // addq $8, %rsi + WORD $0xe1c1; BYTE $0x03 // shll $3, %ecx + WORD $0xf109 // orl %esi, %ecx + WORD $0xd109 // orl %edx, %ecx + WORD $0xc984 // testb %cl, %cl + LONG $0x0108850f; WORD $0x0000 // jne LBB5_72, $264(%rip) + LONG $0x08c38348 // addq $8, %rbx LONG $0x08c78348 // addq $8, %rdi - LONG $0xf8c38348 // addq $-8, %rbx + LONG $0xf8c28349 // addq $-8, %r10 -LBB8_64: - LONG $0x04fb8348 // cmpq $4, %rbx - LONG $0x00448c0f; WORD $0x0000 // jl LBB8_67, $68(%rip) +LBB5_61: + LONG $0x04fa8349 // cmpq $4, %r10 + LONG $0x00498c0f; WORD $0x0000 // jl LBB5_64, $73(%rip) WORD $0xb60f; BYTE $0x0f // movzbl (%rdi), %ecx + LONG $0x0cb60f42; BYTE $0x09 // movzbl (%rcx,%r9), %ecx LONG $0x0157b60f // movzbl $1(%rdi), %edx LONG $0x14b60f42; BYTE $0x0a // movzbl (%rdx,%r9), %edx - WORD $0xd200 // addb %dl, %dl - LONG $0x09140a42 // orb (%rcx,%r9), %dl + WORD $0xd201 // addl %edx, %edx + WORD $0xca09 // orl %ecx, %edx LONG $0x024fb60f // movzbl $2(%rdi), %ecx + LONG $0x34b60f42; BYTE $0x09 // movzbl (%rcx,%r9), %esi + WORD $0xe6c1; BYTE $0x02 // shll $2, %esi + LONG $0x034fb60f // movzbl $3(%rdi), %ecx LONG $0x0cb60f42; BYTE $0x09 // movzbl (%rcx,%r9), %ecx - WORD $0xe1c0; BYTE $0x02 // shlb $2, %cl - WORD $0xd108 // orb %dl, %cl - LONG $0x0357b60f // movzbl $3(%rdi), %edx - LONG $0x14b60f42; BYTE $0x0a // movzbl (%rdx,%r9), %edx - WORD $0xe2c0; BYTE $0x03 // shlb $3, %dl - WORD $0xca08 // orb %cl, %dl - WORD $0x0f8b // movl (%rdi), %ecx - WORD $0x0e89 // movl %ecx, (%rsi) - LONG $0x0094850f; WORD $0x0000 // jne LBB8_75, $148(%rip) - LONG $0x04c68348 // addq $4, %rsi + WORD $0xe1c1; BYTE $0x03 // shll $3, %ecx + WORD $0xf109 // orl %esi, %ecx + WORD $0xd109 // orl %edx, %ecx + WORD $0x178b // movl (%rdi), %edx + WORD $0x1389 // movl %edx, (%rbx) + WORD $0xc984 // testb %cl, %cl + LONG $0x00a4850f; WORD $0x0000 // jne LBB5_71, $164(%rip) + LONG $0x04c38348 // addq $4, %rbx LONG $0x04c78348 // addq $4, %rdi - LONG $0xfcc38348 // addq $-4, %rbx + LONG $0xfcc28349 // addq $-4, %r10 -LBB8_67: - WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx - LONG $0x00aa8e0f; WORD $0x0000 // jle LBB8_77, $170(%rip) +LBB5_64: + WORD $0x854d; BYTE $0xd2 // testq %r10, %r10 + LONG $0x00b98e0f; WORD $0x0000 // jle LBB5_73, $185(%rip) WORD $0x9090 // .p2align 4, 0x90 -LBB8_68: +LBB5_65: WORD $0xb60f; BYTE $0x0f // movzbl (%rdi), %ecx LONG $0x093c8042; BYTE $0x00 // cmpb $0, (%rcx,%r9) - LONG $0x002e850f; WORD $0x0000 // jne LBB8_72, $46(%rip) + LONG $0x0036850f; WORD $0x0000 // jne LBB5_68, $54(%rip) WORD $0xff48; BYTE $0xc7 // incq %rdi - WORD $0x0e88 // movb %cl, (%rsi) - WORD $0xff48; BYTE $0xc6 // incq %rsi - LONG $0xff4b8d48 // leaq $-1(%rbx), %rcx - LONG $0x01fb8348 // cmpq $1, %rbx - WORD $0x8948; BYTE $0xcb // movq %rcx, %rbx - LONG $0xffd98f0f; WORD $0xffff // jg LBB8_68, $-39(%rip) - LONG $0x00007ce9; BYTE $0x00 // jmp LBB8_77, $124(%rip) - -LBB8_70: - LONG $0xc9bc0f66 // bsfw %cx, %cx - WORD $0xb70f; BYTE $0xc9 // movzwl %cx, %ecx + WORD $0x0b88 // movb %cl, (%rbx) + WORD $0xff48; BYTE $0xc3 // incq %rbx + LONG $0xff4a8d49 // leaq $-1(%r10), %rcx + LONG $0x01fa8349 // cmpq $1, %r10 + WORD $0x8949; BYTE $0xca // movq %rcx, %r10 + LONG $0xffd98f0f; WORD $0xffff // jg LBB5_65, $-39(%rip) + LONG $0x00008be9; BYTE $0x00 // jmp LBB5_73, $139(%rip) -LBB8_71: +LBB5_67: + WORD $0xb70f; BYTE $0xce // movzwl %si, %ecx + WORD $0xbc0f; BYTE $0xc9 // bsfl %ecx, %ecx WORD $0x0148; BYTE $0xcf // addq %rcx, %rdi - WORD $0x2948; BYTE $0xcb // subq %rcx, %rbx - WORD $0x0148; BYTE $0xce // addq %rcx, %rsi - -LBB8_72: - WORD $0xb60f; BYTE $0x0f // movzbl (%rdi), %ecx - BYTE $0x90 // .p2align 4, 0x90 + WORD $0x0148; BYTE $0xd7 // addq %rdx, %rdi + WORD $0x2949; BYTE $0xca // subq %rcx, %r10 + WORD $0x2949; BYTE $0xd2 // subq %rdx, %r10 + WORD $0x0148; BYTE $0xcb // addq %rcx, %rbx + WORD $0x0148; BYTE $0xd3 // addq %rdx, %rbx + +LBB5_68: + WORD $0x0f8a // movb (%rdi), %cl + QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90 -LBB8_73: - WORD $0x8948; BYTE $0xf2 // movq %rsi, %rdx +LBB5_69: + WORD $0x8948; BYTE $0xda // movq %rbx, %rdx WORD $0xb60f; BYTE $0xc9 // movzbl %cl, %ecx LONG $0x04e1c148 // shlq $4, %rcx - LONG $0x0c346349 // movslq (%r12,%rcx), %rsi - LONG $0x0c4c8b49; BYTE $0x08 // movq $8(%r12,%rcx), %rcx + LONG $0x081c6349 // movslq (%r8,%rcx), %rbx + LONG $0x084c8b49; BYTE $0x08 // movq $8(%r8,%rcx), %rcx WORD $0x8948; BYTE $0x0a // movq %rcx, (%rdx) - WORD $0x0148; BYTE $0xd6 // addq %rdx, %rsi - LONG $0x02fb8348 // cmpq $2, %rbx - LONG $0x00458c0f; WORD $0x0000 // jl LBB8_77, $69(%rip) - WORD $0xff48; BYTE $0xcb // decq %rbx + WORD $0x0148; BYTE $0xd3 // addq %rdx, %rbx + LONG $0x02fa8349 // cmpq $2, %r10 + LONG $0x00448c0f; WORD $0x0000 // jl LBB5_73, $68(%rip) + WORD $0xff49; BYTE $0xca // decq %r10 LONG $0x014fb60f // movzbl $1(%rdi), %ecx WORD $0xff48; BYTE $0xc7 // incq %rdi LONG $0x093c8042; BYTE $0x00 // cmpb $0, (%rcx,%r9) - LONG $0xffc8850f; WORD $0xffff // jne LBB8_73, $-56(%rip) - LONG $0xfffe58e9; BYTE $0xff // jmp LBB8_57, $-424(%rip) + LONG $0xffc8850f; WORD $0xffff // jne LBB5_69, $-56(%rip) + LONG $0xfffe1fe9; BYTE $0xff // jmp LBB5_52, $-481(%rip) -LBB8_75: - WORD $0xb60f; BYTE $0xca // movzbl %dl, %ecx +LBB5_71: WORD $0xbc0f; BYTE $0xc9 // bsfl %ecx, %ecx - LONG $0xffffabe9; BYTE $0xff // jmp LBB8_71, $-85(%rip) + WORD $0x0148; BYTE $0xcf // addq %rcx, %rdi + WORD $0x2949; BYTE $0xca // subq %rcx, %r10 + WORD $0x0148; BYTE $0xcb // addq %rcx, %rbx + LONG $0xffffa6e9; BYTE $0xff // jmp LBB5_68, $-90(%rip) -LBB8_76: - WORD $0xb60f; BYTE $0xca // movzbl %dl, %ecx +LBB5_72: WORD $0xbc0f; BYTE $0xc9 // bsfl %ecx, %ecx LONG $0x04518d48 // leaq $4(%rcx), %rdx - WORD $0x0148; BYTE $0xcf // addq %rcx, %rdi - LONG $0x04c78348 // addq $4, %rdi - WORD $0x2948; BYTE $0xd3 // subq %rdx, %rbx - WORD $0x0148; BYTE $0xce // addq %rcx, %rsi - LONG $0x04c68348 // addq $4, %rsi - LONG $0xffff94e9; BYTE $0xff // jmp LBB8_72, $-108(%rip) - -LBB8_77: - WORD $0x294c; BYTE $0xfe // subq %r15, %rsi - WORD $0x8949; BYTE $0x33 // movq %rsi, (%r11) - LONG $0x000017e9; BYTE $0x00 // jmp LBB8_81, $23(%rip) - -LBB8_80: - LONG $0xd0752b4c // subq $-48(%rbp), %r14 - LONG $0xc8458b48 // movq $-56(%rbp), %rax - WORD $0x894c; BYTE $0x30 // movq %r14, (%rax) - WORD $0x294c; BYTE $0xcf // subq %r9, %rdi - WORD $0xf749; BYTE $0xd5 // notq %r13 - WORD $0x0149; BYTE $0xfd // addq %rdi, %r13 - WORD $0x894c; BYTE $0xe8 // movq %r13, %rax + LONG $0x0f7c8d48; BYTE $0x04 // leaq $4(%rdi,%rcx), %rdi + WORD $0x2949; BYTE $0xd2 // subq %rdx, %r10 + LONG $0x0b5c8d48; BYTE $0x04 // leaq $4(%rbx,%rcx), %rbx + LONG $0xffff8de9; BYTE $0xff // jmp LBB5_68, $-115(%rip) + +LBB5_73: + WORD $0x294c; BYTE $0xfb // subq %r15, %rbx + LONG $0x005d8949 // movq %rbx, (%r13) + LONG $0x000010e9; BYTE $0x00 // jmp LBB5_77, $16(%rip) + +LBB5_75: + WORD $0x294d; BYTE $0xfb // subq %r15, %r11 + LONG $0x005d894d // movq %r11, (%r13) + WORD $0xf749; BYTE $0xd2 // notq %r10 + WORD $0x0149; BYTE $0xfa // addq %rdi, %r10 + +LBB5_76: + WORD $0x894c; BYTE $0xd0 // movq %r10, %rax -LBB8_81: - LONG $0x20c48348 // addq $32, %rsp +LBB5_77: + LONG $0x08c48348 // addq $8, %rsp BYTE $0x5b // popq %rbx WORD $0x5c41 // popq %r12 WORD $0x5d41 // popq %r13 @@ -2075,40 +1825,21 @@ LBB8_81: BYTE $0x5d // popq %rbp BYTE $0xc3 // retq -LBB8_82: - LONG $0xd04d8b48 // movq $-48(%rbp), %rcx - WORD $0x014c; BYTE $0xe9 // addq %r13, %rcx - WORD $0xf748; BYTE $0xd1 // notq %rcx - WORD $0x014c; BYTE $0xf1 // addq %r14, %rcx - LONG $0xc8458b48 // movq $-56(%rbp), %rax - WORD $0x8948; BYTE $0x08 // movq %rcx, (%rax) - WORD $0x294c; BYTE $0xcf // subq %r9, %rdi - WORD $0x014c; BYTE $0xef // addq %r13, %rdi +LBB5_78: + WORD $0x294d; BYTE $0xfb // subq %r15, %r11 + WORD $0x894c; BYTE $0xc8 // movq %r9, %rax + WORD $0xf748; BYTE $0xd0 // notq %rax + WORD $0x014c; BYTE $0xd8 // addq %r11, %rax + LONG $0x00458949 // movq %rax, (%r13) + WORD $0x294c; BYTE $0xd7 // subq %r10, %rdi + WORD $0x014c; BYTE $0xcf // addq %r9, %rdi WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax - LONG $0xffffcfe9; BYTE $0xff // jmp LBB8_81, $-49(%rip) - LONG $0x00000000; BYTE $0x00 // .p2align 4, 0x00 + LONG $0xffffd3e9; BYTE $0xff // jmp LBB5_77, $-45(%rip) -LCPI9_0: + // .p2align 4, 0x00 +LCPI6_0: QUAD $0x5c5c5c5c5c5c5c5c; QUAD $0x5c5c5c5c5c5c5c5c // .space 16, '\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' -LCPI9_1: - BYTE $0xf0 // .byte 240 - BYTE $0x80 // .byte 128 - BYTE $0x80 // .byte 128 - BYTE $0x80 // .byte 128 - BYTE $0x00 // .space 1, '\x00' - BYTE $0x00 // .space 1, '\x00' - BYTE $0x00 // .space 1, '\x00' - BYTE $0x00 // .space 1, '\x00' - BYTE $0x00 // .space 1, '\x00' - BYTE $0x00 // .space 1, '\x00' - BYTE $0x00 // .space 1, '\x00' - BYTE $0x00 // .space 1, '\x00' - BYTE $0x00 // .space 1, '\x00' - BYTE $0x00 // .space 1, '\x00' - BYTE $0x00 // .space 1, '\x00' - BYTE $0x00 // .space 1, '\x00' - // .p2align 4, 0x90 _unquote: BYTE $0x55 // pushq %rbp @@ -2118,722 +1849,681 @@ _unquote: WORD $0x5541 // pushq %r13 WORD $0x5441 // pushq %r12 BYTE $0x53 // pushq %rbx - LONG $0x48ec8348 // subq $72, %rsp + LONG $0x28ec8348 // subq $40, %rsp WORD $0x8548; BYTE $0xf6 // testq %rsi, %rsi - LONG $0x0683840f; WORD $0x0000 // je LBB9_1, $1667(%rip) - LONG $0xd04d8948 // movq %rcx, $-48(%rbp) + LONG $0x066f840f; WORD $0x0000 // je LBB6_81, $1647(%rip) + WORD $0x8949; BYTE $0xf3 // movq %rsi, %r11 + LONG $0xc84d8948 // movq %rcx, $-56(%rbp) + WORD $0x894c; BYTE $0xc0 // movq %r8, %rax + LONG $0xb845894c // movq %r8, $-72(%rbp) WORD $0x8945; BYTE $0xc2 // movl %r8d, %r10d LONG $0x01e28341 // andl $1, %r10d - LONG $0xd4258d4c; WORD $0x00e5; BYTE $0x00 // leaq $58836(%rip), %r12 /* __UnquoteTab(%rip) */ - QUAD $0xffffffbc0d6ff9c5 // vmovdqa $-68(%rip), %xmm1 /* LCPI9_1(%rip) */ - QUAD $0xffffffa4156ff9c5 // vmovdqa $-92(%rip), %xmm2 /* LCPI9_0(%rip) */ - WORD $0x8949; BYTE $0xff // movq %rdi, %r15 + LONG $0xba058d4c; WORD $0x00ea; BYTE $0x00 // leaq $60090(%rip), %r8 /* __UnquoteTab(%rip) */ + QUAD $0xffffffb2056ff9c5 // vmovdqa $-78(%rip), %xmm0 /* LCPI6_0(%rip) */ + WORD $0x8949; BYTE $0xf9 // movq %rdi, %r9 WORD $0x8949; BYTE $0xf5 // movq %rsi, %r13 - WORD $0x8949; BYTE $0xd6 // movq %rdx, %r14 - LONG $0xb845894c // movq %r8, $-72(%rbp) - -LBB9_4: - LONG $0x5c3f8041 // cmpb $92, (%r15) - LONG $0x000d850f; WORD $0x0000 // jne LBB9_6, $13(%rip) - WORD $0x3145; BYTE $0xdb // xorl %r11d, %r11d - LONG $0x0000c5e9; BYTE $0x00 // jmp LBB9_18, $197(%rip) - LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 + WORD $0x8948; BYTE $0xd0 // movq %rdx, %rax -LBB9_6: - WORD $0x894d; BYTE $0xe9 // movq %r13, %r9 - WORD $0x894c; BYTE $0xf1 // movq %r14, %rcx - WORD $0x894d; BYTE $0xfb // movq %r15, %r11 - LONG $0x10fd8349 // cmpq $16, %r13 - LONG $0x00458c0f; WORD $0x0000 // jl LBB9_12, $69(%rip) - WORD $0xc931 // xorl %ecx, %ecx - WORD $0x894c; BYTE $0xe8 // movq %r13, %rax +LBB6_2: + LONG $0x5c398041 // cmpb $92, (%r9) + LONG $0x000f850f; WORD $0x0000 // jne LBB6_4, $15(%rip) + WORD $0xf631 // xorl %esi, %esi + LONG $0x0000c8e9; BYTE $0x00 // jmp LBB6_13, $200(%rip) QUAD $0x9090909090909090 // .p2align 4, 0x90 -LBB9_8: - LONG $0x6f7ac1c4; WORD $0x0f04 // vmovdqu (%r15,%rcx), %xmm0 - LONG $0x7f7ac1c4; WORD $0x0e04 // vmovdqu %xmm0, (%r14,%rcx) - LONG $0xc274f9c5 // vpcmpeqb %xmm2, %xmm0, %xmm0 - LONG $0xd8d7f9c5 // vpmovmskb %xmm0, %ebx - WORD $0xdb85 // testl %ebx, %ebx - LONG $0x006b850f; WORD $0x0000 // jne LBB9_9, $107(%rip) - LONG $0xf0488d4c // leaq $-16(%rax), %r9 +LBB6_4: + WORD $0x894d; BYTE $0xee // movq %r13, %r14 + WORD $0x8948; BYTE $0xc1 // movq %rax, %rcx + WORD $0x894d; BYTE $0xcf // movq %r9, %r15 + LONG $0x10fd8349 // cmpq $16, %r13 + LONG $0x00408c0f; WORD $0x0000 // jl LBB6_7, $64(%rip) + QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB6_5: + LONG $0x6f7ac1c4; BYTE $0x0f // vmovdqu (%r15), %xmm1 + LONG $0x097ffac5 // vmovdqu %xmm1, (%rcx) + LONG $0xc874f1c5 // vpcmpeqb %xmm0, %xmm1, %xmm1 + LONG $0xf1d7f9c5 // vpmovmskb %xmm1, %esi + WORD $0x8566; BYTE $0xf6 // testw %si, %si + LONG $0x0060850f; WORD $0x0000 // jne LBB6_12, $96(%rip) + LONG $0x10c78349 // addq $16, %r15 LONG $0x10c18348 // addq $16, %rcx - LONG $0x1ff88348 // cmpq $31, %rax - WORD $0x894c; BYTE $0xc8 // movq %r9, %rax - LONG $0xffcf870f; WORD $0xffff // ja LBB9_8, $-49(%rip) - LONG $0x0f1c8d4d // leaq (%r15,%rcx), %r11 - WORD $0x014c; BYTE $0xf1 // addq %r14, %rcx + LONG $0xf0768d49 // leaq $-16(%r14), %rsi + LONG $0x1ffe8349 // cmpq $31, %r14 + WORD $0x8949; BYTE $0xf6 // movq %rsi, %r14 + LONG $0xffcd8f0f; WORD $0xffff // jg LBB6_5, $-51(%rip) -LBB9_12: - WORD $0x854d; BYTE $0xc9 // testq %r9, %r9 - LONG $0x05e2840f; WORD $0x0000 // je LBB9_2, $1506(%rip) - WORD $0xc031 // xorl %eax, %eax - QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 +LBB6_7: + WORD $0x854d; BYTE $0xf6 // testq %r14, %r14 + LONG $0x05d3840f; WORD $0x0000 // je LBB6_82, $1491(%rip) + WORD $0xf631 // xorl %esi, %esi + WORD $0x9090 // .p2align 4, 0x90 -LBB9_14: - LONG $0x1cb60f41; BYTE $0x03 // movzbl (%r11,%rax), %ebx +LBB6_9: + LONG $0x1cb60f41; BYTE $0x37 // movzbl (%r15,%rsi), %ebx WORD $0xfb80; BYTE $0x5c // cmpb $92, %bl - LONG $0x0014840f; WORD $0x0000 // je LBB9_16, $20(%rip) - WORD $0x1c88; BYTE $0x01 // movb %bl, (%rcx,%rax) - WORD $0xff48; BYTE $0xc0 // incq %rax - WORD $0x3949; BYTE $0xc1 // cmpq %rax, %r9 - LONG $0xffe3850f; WORD $0xffff // jne LBB9_14, $-29(%rip) - LONG $0x0005b1e9; BYTE $0x00 // jmp LBB9_2, $1457(%rip) + LONG $0x0014840f; WORD $0x0000 // je LBB6_11, $20(%rip) + WORD $0x1c88; BYTE $0x31 // movb %bl, (%rcx,%rsi) + WORD $0xff48; BYTE $0xc6 // incq %rsi + WORD $0x3949; BYTE $0xf6 // cmpq %rsi, %r14 + LONG $0xffe3850f; WORD $0xffff // jne LBB6_9, $-29(%rip) + LONG $0x0005ade9; BYTE $0x00 // jmp LBB6_82, $1453(%rip) -LBB9_16: - WORD $0x294d; BYTE $0xfb // subq %r15, %r11 - WORD $0x0149; BYTE $0xc3 // addq %rax, %r11 - LONG $0xfffb8349 // cmpq $-1, %r11 - LONG $0x001e850f; WORD $0x0000 // jne LBB9_18, $30(%rip) - LONG $0x00059ce9; BYTE $0x00 // jmp LBB9_2, $1436(%rip) - -LBB9_9: - LONG $0xc3bc0f66 // bsfw %bx, %ax - LONG $0xd8b70f44 // movzwl %ax, %r11d - WORD $0x0149; BYTE $0xcb // addq %rcx, %r11 - LONG $0xfffb8349 // cmpq $-1, %r11 - LONG $0x0587840f; WORD $0x0000 // je LBB9_2, $1415(%rip) - LONG $0x90909090 // .p2align 4, 0x90 +LBB6_11: + WORD $0x0149; BYTE $0xf7 // addq %rsi, %r15 + WORD $0x294d; BYTE $0xcf // subq %r9, %r15 + WORD $0x894c; BYTE $0xfe // movq %r15, %rsi + LONG $0xfffe8348 // cmpq $-1, %rsi + LONG $0x002b850f; WORD $0x0000 // jne LBB6_13, $43(%rip) + LONG $0x000595e9; BYTE $0x00 // jmp LBB6_82, $1429(%rip) + +LBB6_12: + WORD $0xb70f; BYTE $0xce // movzwl %si, %ecx + WORD $0x294d; BYTE $0xcf // subq %r9, %r15 + LONG $0xf1bc0f48 // bsfq %rcx, %rsi + WORD $0x014c; BYTE $0xfe // addq %r15, %rsi + LONG $0xfffe8348 // cmpq $-1, %rsi + LONG $0x057e840f; WORD $0x0000 // je LBB6_82, $1406(%rip) + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 -LBB9_18: - LONG $0x024b8d49 // leaq $2(%r11), %rcx +LBB6_13: + LONG $0x024e8d48 // leaq $2(%rsi), %rcx WORD $0x2949; BYTE $0xcd // subq %rcx, %r13 - LONG $0x0642880f; WORD $0x0000 // js LBB9_19, $1602(%rip) - WORD $0x014d; BYTE $0xdf // addq %r11, %r15 - LONG $0x02c78349 // addq $2, %r15 + LONG $0x075b880f; WORD $0x0000 // js LBB6_111, $1883(%rip) + LONG $0x314c8d4d; BYTE $0x02 // leaq $2(%r9,%rsi), %r9 WORD $0x854d; BYTE $0xd2 // testq %r10, %r10 - LONG $0x028d850f; WORD $0x0000 // jne LBB9_21, $653(%rip) - -LBB9_32: - WORD $0x014d; BYTE $0xde // addq %r11, %r14 - LONG $0x47b60f41; BYTE $0xff // movzbl $-1(%r15), %eax - LONG $0x04b60f42; BYTE $0x20 // movzbl (%rax,%r12), %eax - LONG $0x0000ff3d; BYTE $0x00 // cmpl $255, %eax - LONG $0x002b840f; WORD $0x0000 // je LBB9_38, $43(%rip) - WORD $0xc085 // testl %eax, %eax - LONG $0x062d840f; WORD $0x0000 // je LBB9_34, $1581(%rip) - WORD $0x8841; BYTE $0x06 // movb %al, (%r14) - WORD $0xff49; BYTE $0xc6 // incq %r14 - WORD $0x854d; BYTE $0xed // testq %r13, %r13 - LONG $0xfedd850f; WORD $0xffff // jne LBB9_4, $-291(%rip) - LONG $0x000611e9; BYTE $0x00 // jmp LBB9_37, $1553(%rip) - QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + LONG $0x03f5850f; WORD $0x0000 // jne LBB6_58, $1013(%rip) + +LBB6_15: + WORD $0x0148; BYTE $0xf0 // addq %rsi, %rax + LONG $0x49b60f41; BYTE $0xff // movzbl $-1(%r9), %ecx + LONG $0x010c8a42 // movb (%rcx,%r8), %cl + WORD $0xf980; BYTE $0xff // cmpb $-1, %cl + LONG $0x0020840f; WORD $0x0000 // je LBB6_18, $32(%rip) + WORD $0xc984 // testb %cl, %cl + LONG $0x0600840f; WORD $0x0000 // je LBB6_93, $1536(%rip) + WORD $0x0888 // movb %cl, (%rax) + WORD $0xff48; BYTE $0xc0 // incq %rax + LONG $0x0003c0e9; BYTE $0x00 // jmp LBB6_57, $960(%rip) + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 -LBB9_38: +LBB6_18: LONG $0x03fd8349 // cmpq $3, %r13 - LONG $0x05e5860f; WORD $0x0000 // jbe LBB9_19, $1509(%rip) - WORD $0x8b41; BYTE $0x1f // movl (%r15), %ebx - WORD $0xd989 // movl %ebx, %ecx + LONG $0x070e8e0f; WORD $0x0000 // jle LBB6_111, $1806(%rip) + WORD $0x8b41; BYTE $0x31 // movl (%r9), %esi + WORD $0xf189 // movl %esi, %ecx WORD $0xd1f7 // notl %ecx - LONG $0xcfd0838d; WORD $0xcfcf // leal $-808464432(%rbx), %eax + LONG $0xcfd09e8d; WORD $0xcfcf // leal $-808464432(%rsi), %ebx LONG $0x8080e181; WORD $0x8080 // andl $-2139062144, %ecx - WORD $0xc185 // testl %eax, %ecx - LONG $0x0516850f; WORD $0x0000 // jne LBB9_43, $1302(%rip) - LONG $0x1919838d; WORD $0x1919 // leal $421075225(%rbx), %eax - WORD $0xd809 // orl %ebx, %eax - LONG $0x808080a9; BYTE $0x80 // testl $-2139062144, %eax - LONG $0x0503850f; WORD $0x0000 // jne LBB9_43, $1283(%rip) - WORD $0xd889 // movl %ebx, %eax - LONG $0x7f7f7f25; BYTE $0x7f // andl $2139062143, %eax - LONG $0xc0c0bb41; WORD $0xc0c0 // movl $-1061109568, %r11d - WORD $0x2941; BYTE $0xc3 // subl %eax, %r11d - LONG $0x46888d44; WORD $0x4646; BYTE $0x46 // leal $1179010630(%rax), %r9d - WORD $0x2141; BYTE $0xcb // andl %ecx, %r11d - WORD $0x8545; BYTE $0xcb // testl %r9d, %r11d - LONG $0x04e0850f; WORD $0x0000 // jne LBB9_43, $1248(%rip) - LONG $0xe0e0b941; WORD $0xe0e0 // movl $-522133280, %r9d - WORD $0x2941; BYTE $0xc1 // subl %eax, %r9d - LONG $0x39393905; BYTE $0x39 // addl $960051513, %eax - WORD $0x2144; BYTE $0xc9 // andl %r9d, %ecx - WORD $0xc185 // testl %eax, %ecx - LONG $0x04c7850f; WORD $0x0000 // jne LBB9_43, $1223(%rip) - WORD $0xcb0f // bswapl %ebx - WORD $0xd989 // movl %ebx, %ecx - WORD $0xd1f7 // notl %ecx + WORD $0xd985 // testl %ebx, %ecx + LONG $0x050f850f; WORD $0x0000 // jne LBB6_84, $1295(%rip) + LONG $0x19199e8d; WORD $0x1919 // leal $421075225(%rsi), %ebx + WORD $0xf309 // orl %esi, %ebx + LONG $0x8080c3f7; WORD $0x8080 // testl $-2139062144, %ebx + LONG $0x04fb850f; WORD $0x0000 // jne LBB6_84, $1275(%rip) + WORD $0xf389 // movl %esi, %ebx + LONG $0x7f7fe381; WORD $0x7f7f // andl $2139062143, %ebx + LONG $0xc0c0be41; WORD $0xc0c0 // movl $-1061109568, %r14d + WORD $0x2941; BYTE $0xde // subl %ebx, %r14d + LONG $0x46bb8d44; WORD $0x4646; BYTE $0x46 // leal $1179010630(%rbx), %r15d + WORD $0x2141; BYTE $0xce // andl %ecx, %r14d + WORD $0x8545; BYTE $0xfe // testl %r15d, %r14d + LONG $0x04d7850f; WORD $0x0000 // jne LBB6_84, $1239(%rip) + LONG $0xe0e0be41; WORD $0xe0e0 // movl $-522133280, %r14d + WORD $0x2941; BYTE $0xde // subl %ebx, %r14d + LONG $0x3939c381; WORD $0x3939 // addl $960051513, %ebx + WORD $0x2144; BYTE $0xf1 // andl %r14d, %ecx + WORD $0xd985 // testl %ebx, %ecx + LONG $0x04bd850f; WORD $0x0000 // jne LBB6_84, $1213(%rip) + WORD $0xce0f // bswapl %esi + WORD $0xf189 // movl %esi, %ecx WORD $0xe9c1; BYTE $0x04 // shrl $4, %ecx + WORD $0xd1f7 // notl %ecx LONG $0x0101e181; WORD $0x0101 // andl $16843009, %ecx WORD $0x0c8d; BYTE $0xc9 // leal (%rcx,%rcx,8), %ecx - LONG $0x0f0fe381; WORD $0x0f0f // andl $252645135, %ebx - WORD $0xcb01 // addl %ecx, %ebx - WORD $0xd989 // movl %ebx, %ecx + LONG $0x0f0fe681; WORD $0x0f0f // andl $252645135, %esi + WORD $0xce01 // addl %ecx, %esi + WORD $0xf189 // movl %esi, %ecx WORD $0xe9c1; BYTE $0x04 // shrl $4, %ecx - WORD $0xd909 // orl %ebx, %ecx - WORD $0xb60f; BYTE $0xd9 // movzbl %cl, %ebx + WORD $0xf109 // orl %esi, %ecx + LONG $0xf9b60f44 // movzbl %cl, %r15d WORD $0xe9c1; BYTE $0x08 // shrl $8, %ecx LONG $0xff00e181; WORD $0x0000 // andl $65280, %ecx - WORD $0xcb09 // orl %ecx, %ebx - LONG $0x044f8d4d // leaq $4(%r15), %r9 - LONG $0xfc4d8d49 // leaq $-4(%r13), %rcx - LONG $0x0080fb81; WORD $0x0000 // cmpl $128, %ebx - LONG $0x01e3820f; WORD $0x0000 // jb LBB9_54, $483(%rip) - LONG $0x02c0f641 // testb $2, %r8b - LONG $0x01ea840f; WORD $0x0000 // je LBB9_65, $490(%rip) - WORD $0x894d; BYTE $0xcf // movq %r9, %r15 - WORD $0x8941; BYTE $0xdc // movl %ebx, %r12d - WORD $0x8949; BYTE $0xcd // movq %rcx, %r13 - -LBB9_59: - LONG $0xfffc8141; WORD $0x0007; BYTE $0x00 // cmpl $2047, %r12d - LONG $0x02e3860f; WORD $0x0000 // jbe LBB9_67, $739(%rip) - QUAD $0xffff200024848d41 // leal $-57344(%r12), %eax - LONG $0xfff7ff3d; BYTE $0xff // cmpl $-2049, %eax - LONG $0x01f6860f; WORD $0x0000 // jbe LBB9_70, $502(%rip) + WORD $0x0941; BYTE $0xcf // orl %ecx, %r15d + LONG $0xfc758d4d // leaq $-4(%r13), %r14 + LONG $0x80ff8141; WORD $0x0000; BYTE $0x00 // cmpl $128, %r15d + LONG $0x0356820f; WORD $0x0000 // jb LBB6_66, $854(%rip) + WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d WORD $0x854d; BYTE $0xd2 // testq %r10, %r10 - LONG $0xc07d8948 // movq %rdi, $-64(%rbp) + LONG $0x014b850f; WORD $0x0000 // jne LBB6_38, $331(%rip) + +LBB6_25: + LONG $0x00ff8141; WORD $0x0008; BYTE $0x00 // cmpl $2048, %r15d + LONG $0x034c820f; WORD $0x0000 // jb LBB6_68, $844(%rip) + WORD $0x8944; BYTE $0xf9 // movl %r15d, %ecx + LONG $0xf800e181; WORD $0xffff // andl $-2048, %ecx + LONG $0xd800f981; WORD $0x0000 // cmpl $55296, %ecx + LONG $0x0299850f; WORD $0x0000 // jne LBB6_54, $665(%rip) + LONG $0xffff8141; WORD $0x00db; BYTE $0x00 // cmpl $56319, %r15d + LONG $0x034f870f; WORD $0x0000 // ja LBB6_69, $847(%rip) + LONG $0x06fe8349 // cmpq $6, %r14 + LONG $0x03458c0f; WORD $0x0000 // jl LBB6_69, $837(%rip) + LONG $0x217c8043; WORD $0x5c04 // cmpb $92, $4(%r9,%r12) + LONG $0x0339850f; WORD $0x0000 // jne LBB6_69, $825(%rip) + LONG $0x217c8043; WORD $0x7505 // cmpb $117, $5(%r9,%r12) + LONG $0x032d850f; WORD $0x0000 // jne LBB6_69, $813(%rip) + LONG $0x21748b43; BYTE $0x06 // movl $6(%r9,%r12), %esi + WORD $0xf189 // movl %esi, %ecx + WORD $0xd1f7 // notl %ecx + LONG $0xcfd09e8d; WORD $0xcfcf // leal $-808464432(%rsi), %ebx + LONG $0x8080e181; WORD $0x8080 // andl $-2139062144, %ecx + WORD $0xd985 // testl %ebx, %ecx + LONG $0x04d9850f; WORD $0x0000 // jne LBB6_95, $1241(%rip) + LONG $0x19199e8d; WORD $0x1919 // leal $421075225(%rsi), %ebx + WORD $0xf309 // orl %esi, %ebx + LONG $0x8080c3f7; WORD $0x8080 // testl $-2139062144, %ebx + LONG $0x04c5850f; WORD $0x0000 // jne LBB6_95, $1221(%rip) + WORD $0xf389 // movl %esi, %ebx + LONG $0x7f7fe381; WORD $0x7f7f // andl $2139062143, %ebx + LONG $0xc0d445c7; WORD $0xc0c0; BYTE $0xc0 // movl $-1061109568, $-44(%rbp) + WORD $0x5d29; BYTE $0xd4 // subl %ebx, $-44(%rbp) LONG $0xb0758948 // movq %rsi, $-80(%rbp) - LONG $0x00d2850f; WORD $0x0000 // jne LBB9_62, $210(%rip) - LONG $0xa855894c // movq %r10, $-88(%rbp) - LONG $0xa0558948 // movq %rdx, $-96(%rbp) - LONG $0x06fd8349 // cmpq $6, %r13 - LONG $0x00eb8c0f; WORD $0x0000 // jl LBB9_94, $235(%rip) - -LBB9_91: - LONG $0xfffc8141; WORD $0x00db; BYTE $0x00 // cmpl $56319, %r12d - LONG $0x00de870f; WORD $0x0000 // ja LBB9_94, $222(%rip) - LONG $0x5c3f8041 // cmpb $92, (%r15) - LONG $0x00d4850f; WORD $0x0000 // jne LBB9_94, $212(%rip) - LONG $0x017f8041; BYTE $0x75 // cmpb $117, $1(%r15) - LONG $0x00c9850f; WORD $0x0000 // jne LBB9_94, $201(%rip) - LONG $0x025f8b41 // movl $2(%r15), %ebx - WORD $0xdf89 // movl %ebx, %edi - LONG $0x000636e8; BYTE $0x00 // callq _unhex16_is, $1590(%rip) - WORD $0xc084 // testb %al, %al - LONG $0x052a840f; WORD $0x0000 // je LBB9_100, $1322(%rip) - WORD $0xcb0f // bswapl %ebx - WORD $0xd889 // movl %ebx, %eax - WORD $0xd0f7 // notl %eax - WORD $0xe8c1; BYTE $0x04 // shrl $4, %eax - LONG $0x01010125; BYTE $0x01 // andl $16843009, %eax - WORD $0x048d; BYTE $0xc0 // leal (%rax,%rax,8), %eax - LONG $0x0f0fe381; WORD $0x0f0f // andl $252645135, %ebx - WORD $0xc301 // addl %eax, %ebx - WORD $0xd889 // movl %ebx, %eax - WORD $0xe8c1; BYTE $0x04 // shrl $4, %eax - WORD $0xd809 // orl %ebx, %eax - WORD $0xb60f; BYTE $0xc8 // movzbl %al, %ecx - WORD $0xe8c1; BYTE $0x08 // shrl $8, %eax - LONG $0x00ff0025; BYTE $0x00 // andl $65280, %eax - WORD $0x1c8d; BYTE $0x08 // leal (%rax,%rcx), %ebx - LONG $0x06c78349 // addq $6, %r15 - LONG $0xfac58349 // addq $-6, %r13 - WORD $0xc801 // addl %ecx, %eax - LONG $0xff200005; BYTE $0xff // addl $-57344, %eax - LONG $0xfffbff3d; BYTE $0xff // cmpl $-1025, %eax - LONG $0xc07d8b48 // movq $-64(%rbp), %rdi - LONG $0xa0558b48 // movq $-96(%rbp), %rdx + LONG $0x4646b38d; WORD $0x4646 // leal $1179010630(%rbx), %esi + WORD $0x7589; BYTE $0xc4 // movl %esi, $-60(%rbp) + WORD $0x4d21; BYTE $0xd4 // andl %ecx, $-44(%rbp) + WORD $0x758b; BYTE $0xc4 // movl $-60(%rbp), %esi + WORD $0x7585; BYTE $0xd4 // testl %esi, $-44(%rbp) LONG $0xb0758b48 // movq $-80(%rbp), %rsi - QUAD $0xfffffcd80d6ff9c5 // vmovdqa $-808(%rip), %xmm1 /* LCPI9_1(%rip) */ - QUAD $0xfffffcc0156ff9c5 // vmovdqa $-832(%rip), %xmm2 /* LCPI9_0(%rip) */ - LONG $0x017c870f; WORD $0x0000 // ja LBB9_110, $380(%rip) - LONG $0x06c74166; WORD $0xbfef // movw $-16401, (%r14) - LONG $0x0246c641; BYTE $0xbd // movb $-67, $2(%r14) - LONG $0x03c68349 // addq $3, %r14 - WORD $0x8941; BYTE $0xdc // movl %ebx, %r12d + LONG $0x0493850f; WORD $0x0000 // jne LBB6_95, $1171(%rip) + LONG $0xe0d445c7; WORD $0xe0e0; BYTE $0xe0 // movl $-522133280, $-44(%rbp) + WORD $0x5d29; BYTE $0xd4 // subl %ebx, $-44(%rbp) + LONG $0x3939c381; WORD $0x3939 // addl $960051513, %ebx + WORD $0x4d23; BYTE $0xd4 // andl $-44(%rbp), %ecx + WORD $0xd985 // testl %ebx, %ecx + LONG $0x0478850f; WORD $0x0000 // jne LBB6_95, $1144(%rip) + WORD $0xce0f // bswapl %esi + WORD $0xf189 // movl %esi, %ecx + WORD $0xe9c1; BYTE $0x04 // shrl $4, %ecx + WORD $0xd1f7 // notl %ecx + LONG $0x0101e181; WORD $0x0101 // andl $16843009, %ecx + WORD $0x0c8d; BYTE $0xc9 // leal (%rcx,%rcx,8), %ecx + LONG $0x0f0fe681; WORD $0x0f0f // andl $252645135, %esi + WORD $0xce01 // addl %ecx, %esi + WORD $0xf189 // movl %esi, %ecx + WORD $0xe9c1; BYTE $0x04 // shrl $4, %ecx + WORD $0xf109 // orl %esi, %ecx + WORD $0xce89 // movl %ecx, %esi + WORD $0xeec1; BYTE $0x08 // shrl $8, %esi + LONG $0xff00e681; WORD $0x0000 // andl $65280, %esi + WORD $0xb60f; BYTE $0xd9 // movzbl %cl, %ebx + WORD $0xf309 // orl %esi, %ebx + LONG $0x0000e181; WORD $0x00fc // andl $16515072, %ecx + LONG $0x0000f981; WORD $0x00dc // cmpl $14417920, %ecx + LONG $0x02b1840f; WORD $0x0000 // je LBB6_75, $689(%rip) + LONG $0x02b845f6 // testb $2, $-72(%rbp) + LONG $0x0564840f; WORD $0x0000 // je LBB6_114, $1380(%rip) + LONG $0xfac68349 // addq $-6, %r14 + LONG $0xef00c766; BYTE $0xbf // movw $-16401, (%rax) + LONG $0xbd0240c6 // movb $-67, $2(%rax) + LONG $0x03c08348 // addq $3, %rax + LONG $0x06c48349 // addq $6, %r12 + WORD $0x8941; BYTE $0xdf // movl %ebx, %r15d + WORD $0xfb83; BYTE $0x7f // cmpl $127, %ebx + LONG $0xfec3870f; WORD $0xffff // ja LBB6_25, $-317(%rip) + LONG $0x00015ee9; BYTE $0x00 // jmp LBB6_53, $350(%rip) + QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB6_38: + LONG $0x00ff8141; WORD $0x0008; BYTE $0x00 // cmpl $2048, %r15d + LONG $0x0201820f; WORD $0x0000 // jb LBB6_68, $513(%rip) + WORD $0x8944; BYTE $0xf9 // movl %r15d, %ecx + LONG $0xf800e181; WORD $0xffff // andl $-2048, %ecx + LONG $0xd800f981; WORD $0x0000 // cmpl $55296, %ecx + LONG $0x014e850f; WORD $0x0000 // jne LBB6_54, $334(%rip) + WORD $0x854d; BYTE $0xf6 // testq %r14, %r14 + LONG $0x04be8e0f; WORD $0x0000 // jle LBB6_108, $1214(%rip) + LONG $0x217c8043; WORD $0x5c04 // cmpb $92, $4(%r9,%r12) + LONG $0x022d850f; WORD $0x0000 // jne LBB6_73, $557(%rip) + LONG $0xffff8141; WORD $0x00db; BYTE $0x00 // cmpl $56319, %r15d + LONG $0x01f9870f; WORD $0x0000 // ja LBB6_70, $505(%rip) + LONG $0x07fe8349 // cmpq $7, %r14 + LONG $0x01ef8c0f; WORD $0x0000 // jl LBB6_70, $495(%rip) + LONG $0x217c8043; WORD $0x5c05 // cmpb $92, $5(%r9,%r12) + LONG $0x01e3850f; WORD $0x0000 // jne LBB6_70, $483(%rip) + LONG $0x217c8043; WORD $0x7506 // cmpb $117, $6(%r9,%r12) + LONG $0x01d7850f; WORD $0x0000 // jne LBB6_70, $471(%rip) + LONG $0x21748b43; BYTE $0x07 // movl $7(%r9,%r12), %esi + WORD $0xf189 // movl %esi, %ecx + WORD $0xd1f7 // notl %ecx + LONG $0xcfd09e8d; WORD $0xcfcf // leal $-808464432(%rsi), %ebx + LONG $0x8080e181; WORD $0x8080 // andl $-2139062144, %ecx + WORD $0xd985 // testl %ebx, %ecx + LONG $0x0383850f; WORD $0x0000 // jne LBB6_96, $899(%rip) + LONG $0x19199e8d; WORD $0x1919 // leal $421075225(%rsi), %ebx + WORD $0xf309 // orl %esi, %ebx + LONG $0x8080c3f7; WORD $0x8080 // testl $-2139062144, %ebx + LONG $0x036f850f; WORD $0x0000 // jne LBB6_96, $879(%rip) + WORD $0xf389 // movl %esi, %ebx + LONG $0x7f7fe381; WORD $0x7f7f // andl $2139062143, %ebx + LONG $0xc0d445c7; WORD $0xc0c0; BYTE $0xc0 // movl $-1061109568, $-44(%rbp) + WORD $0x5d29; BYTE $0xd4 // subl %ebx, $-44(%rbp) + LONG $0xb0758948 // movq %rsi, $-80(%rbp) + LONG $0x4646b38d; WORD $0x4646 // leal $1179010630(%rbx), %esi + WORD $0x7589; BYTE $0xc4 // movl %esi, $-60(%rbp) + WORD $0x4d21; BYTE $0xd4 // andl %ecx, $-44(%rbp) + WORD $0x758b; BYTE $0xc4 // movl $-60(%rbp), %esi + WORD $0x7585; BYTE $0xd4 // testl %esi, $-44(%rbp) + LONG $0xb0758b48 // movq $-80(%rbp), %rsi + LONG $0x033d850f; WORD $0x0000 // jne LBB6_96, $829(%rip) + LONG $0xe0d445c7; WORD $0xe0e0; BYTE $0xe0 // movl $-522133280, $-44(%rbp) + WORD $0x5d29; BYTE $0xd4 // subl %ebx, $-44(%rbp) + LONG $0x3939c381; WORD $0x3939 // addl $960051513, %ebx + WORD $0x4d23; BYTE $0xd4 // andl $-44(%rbp), %ecx + WORD $0xd985 // testl %ebx, %ecx + LONG $0x0322850f; WORD $0x0000 // jne LBB6_96, $802(%rip) + WORD $0xce0f // bswapl %esi + WORD $0xf189 // movl %esi, %ecx + WORD $0xe9c1; BYTE $0x04 // shrl $4, %ecx + WORD $0xd1f7 // notl %ecx + LONG $0x0101e181; WORD $0x0101 // andl $16843009, %ecx + WORD $0x0c8d; BYTE $0xc9 // leal (%rcx,%rcx,8), %ecx + LONG $0x0f0fe681; WORD $0x0f0f // andl $252645135, %esi + WORD $0xce01 // addl %ecx, %esi + WORD $0xf189 // movl %esi, %ecx + WORD $0xe9c1; BYTE $0x04 // shrl $4, %ecx + WORD $0xf109 // orl %esi, %ecx + WORD $0xce89 // movl %ecx, %esi + WORD $0xeec1; BYTE $0x08 // shrl $8, %esi + LONG $0xff00e681; WORD $0x0000 // andl $65280, %esi + WORD $0xb60f; BYTE $0xd9 // movzbl %cl, %ebx + WORD $0xf309 // orl %esi, %ebx + LONG $0x0000e181; WORD $0x00fc // andl $16515072, %ecx + LONG $0x0000f981; WORD $0x00dc // cmpl $14417920, %ecx + LONG $0x0162840f; WORD $0x0000 // je LBB6_76, $354(%rip) + LONG $0x02b845f6 // testb $2, $-72(%rbp) + LONG $0x040e840f; WORD $0x0000 // je LBB6_115, $1038(%rip) + LONG $0xf9c68349 // addq $-7, %r14 + LONG $0xef00c766; BYTE $0xbf // movw $-16401, (%rax) + LONG $0xbd0240c6 // movb $-67, $2(%rax) + LONG $0x03c08348 // addq $3, %rax + LONG $0x07c48349 // addq $7, %r12 + WORD $0x8941; BYTE $0xdf // movl %ebx, %r15d LONG $0x0080fb81; WORD $0x0000 // cmpl $128, %ebx - LONG $0xa8558b4c // movq $-88(%rbp), %r10 - LONG $0xff02830f; WORD $0xffff // jae LBB9_59, $-254(%rip) - LONG $0x0000d3e9; BYTE $0x00 // jmp LBB9_55, $211(%rip) + LONG $0xfeab830f; WORD $0xffff // jae LBB6_38, $-341(%rip) -LBB9_62: - WORD $0x854d; BYTE $0xed // testq %r13, %r13 - LONG $0x04718e0f; WORD $0x0000 // jle LBB9_63, $1137(%rip) - LONG $0x5c3f8041 // cmpb $92, (%r15) - LONG $0x02bf850f; WORD $0x0000 // jne LBB9_96, $703(%rip) - WORD $0xff49; BYTE $0xcd // decq %r13 - WORD $0xff49; BYTE $0xc7 // incq %r15 - LONG $0xa855894c // movq %r10, $-88(%rbp) - LONG $0xa0558948 // movq %rdx, $-96(%rbp) - LONG $0x06fd8349 // cmpq $6, %r13 - LONG $0xff158d0f; WORD $0xffff // jge LBB9_91, $-235(%rip) +LBB6_53: + LONG $0x214c8d4f; BYTE $0x04 // leaq $4(%r9,%r12), %r9 + WORD $0x8941; BYTE $0xdf // movl %ebx, %r15d + LONG $0x0000a1e9; BYTE $0x00 // jmp LBB6_67, $161(%rip) + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 -LBB9_94: - LONG $0x02b845f6 // testb $2, $-72(%rbp) - LONG $0x02f9840f; WORD $0x0000 // je LBB9_77, $761(%rip) - LONG $0x06c74166; WORD $0xbfef // movw $-16401, (%r14) - LONG $0x0246c641; BYTE $0xbd // movb $-67, $2(%r14) - LONG $0x03c68349 // addq $3, %r14 - LONG $0xc07d8b48 // movq $-64(%rbp), %rdi - LONG $0xa0558b48 // movq $-96(%rbp), %rdx - LONG $0xa8558b4c // movq $-88(%rbp), %r10 - LONG $0xb0758b48 // movq $-80(%rbp), %rsi - LONG $0xb8458b4c // movq $-72(%rbp), %r8 - LONG $0x54258d4c; WORD $0x00e2; BYTE $0x00 // leaq $57940(%rip), %r12 /* __UnquoteTab(%rip) */ - QUAD $0xfffffc3c0d6ff9c5 // vmovdqa $-964(%rip), %xmm1 /* LCPI9_1(%rip) */ - QUAD $0xfffffc24156ff9c5 // vmovdqa $-988(%rip), %xmm2 /* LCPI9_0(%rip) */ - WORD $0x854d; BYTE $0xed // testq %r13, %r13 - LONG $0xfc84850f; WORD $0xffff // jne LBB9_4, $-892(%rip) - LONG $0x0003b8e9; BYTE $0x00 // jmp LBB9_37, $952(%rip) +LBB6_54: + LONG $0x214c8d4f; BYTE $0x04 // leaq $4(%r9,%r12), %r9 + WORD $0x8944; BYTE $0xf9 // movl %r15d, %ecx + WORD $0xe9c1; BYTE $0x0c // shrl $12, %ecx + WORD $0xc980; BYTE $0xe0 // orb $-32, %cl + WORD $0x0888 // movb %cl, (%rax) + WORD $0x8944; BYTE $0xf9 // movl %r15d, %ecx + WORD $0xe9c1; BYTE $0x06 // shrl $6, %ecx + WORD $0xe180; BYTE $0x3f // andb $63, %cl + WORD $0xc980; BYTE $0x80 // orb $-128, %cl + WORD $0x4888; BYTE $0x01 // movb %cl, $1(%rax) + LONG $0x3fe78041 // andb $63, %r15b + LONG $0x80cf8041 // orb $-128, %r15b + LONG $0x02788844 // movb %r15b, $2(%rax) + +LBB6_55: + LONG $0x03c08348 // addq $3, %rax + +LBB6_56: + WORD $0x894d; BYTE $0xf5 // movq %r14, %r13 + +LBB6_57: + WORD $0x854d; BYTE $0xed // testq %r13, %r13 + LONG $0xfb1c850f; WORD $0xffff // jne LBB6_2, $-1252(%rip) + LONG $0x000350e9; BYTE $0x00 // jmp LBB6_110, $848(%rip) -LBB9_21: +LBB6_58: WORD $0x8545; BYTE $0xed // testl %r13d, %r13d - LONG $0x039c840f; WORD $0x0000 // je LBB9_19, $924(%rip) - LONG $0xff7f8041; BYTE $0x5c // cmpb $92, $-1(%r15) - LONG $0x03c5850f; WORD $0x0000 // jne LBB9_23, $965(%rip) - LONG $0x5c3f8041 // cmpb $92, (%r15) - LONG $0x0027850f; WORD $0x0000 // jne LBB9_31, $39(%rip) + LONG $0x034f840f; WORD $0x0000 // je LBB6_111, $847(%rip) + LONG $0xff798041; BYTE $0x5c // cmpb $92, $-1(%r9) + LONG $0x022d850f; WORD $0x0000 // jne LBB6_94, $557(%rip) + LONG $0x5c398041 // cmpb $92, (%r9) + LONG $0x0026850f; WORD $0x0000 // jne LBB6_65, $38(%rip) LONG $0x01fd8341 // cmpl $1, %r13d - LONG $0x037d8e0f; WORD $0x0000 // jle LBB9_19, $893(%rip) - LONG $0x4fb60f41; BYTE $0x01 // movzbl $1(%r15), %ecx - WORD $0xf983; BYTE $0x22 // cmpl $34, %ecx - LONG $0x0009840f; WORD $0x0000 // je LBB9_30, $9(%rip) - WORD $0xf983; BYTE $0x5c // cmpl $92, %ecx - LONG $0x03b3850f; WORD $0x0000 // jne LBB9_29, $947(%rip) - -LBB9_30: - WORD $0xff49; BYTE $0xc7 // incq %r15 + LONG $0x03308e0f; WORD $0x0000 // jle LBB6_111, $816(%rip) + LONG $0x01498a41 // movb $1(%r9), %cl + WORD $0xf980; BYTE $0x22 // cmpb $34, %cl + LONG $0x0009840f; WORD $0x0000 // je LBB6_64, $9(%rip) + WORD $0xf980; BYTE $0x5c // cmpb $92, %cl + LONG $0x02e2850f; WORD $0x0000 // jne LBB6_106, $738(%rip) + +LBB6_64: + WORD $0xff49; BYTE $0xc1 // incq %r9 WORD $0xff49; BYTE $0xcd // decq %r13 -LBB9_31: - WORD $0xff49; BYTE $0xc7 // incq %r15 +LBB6_65: + WORD $0xff49; BYTE $0xc1 // incq %r9 WORD $0xff49; BYTE $0xcd // decq %r13 - LONG $0xfffd23e9; BYTE $0xff // jmp LBB9_32, $-733(%rip) - -LBB9_54: - WORD $0x8949; BYTE $0xcd // movq %rcx, %r13 - WORD $0x894d; BYTE $0xcf // movq %r9, %r15 - -LBB9_55: - WORD $0x8841; BYTE $0x1e // movb %bl, (%r14) - WORD $0xff49; BYTE $0xc6 // incq %r14 - LONG $0x00005ee9; BYTE $0x00 // jmp LBB9_56, $94(%rip) - -LBB9_65: - LONG $0x0800fb81; WORD $0x0000 // cmpl $2048, %ebx - LONG $0x00fa820f; WORD $0x0000 // jb LBB9_66, $250(%rip) - LONG $0x2000838d; WORD $0xffff // leal $-57344(%rbx), %eax - LONG $0xfff8003d; BYTE $0xff // cmpl $-2048, %eax - LONG $0x0112830f; WORD $0x0000 // jae LBB9_71, $274(%rip) - WORD $0x8949; BYTE $0xcd // movq %rcx, %r13 - WORD $0x8941; BYTE $0xdc // movl %ebx, %r12d - WORD $0x894d; BYTE $0xcf // movq %r9, %r15 - QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + LONG $0xfffbbce9; BYTE $0xff // jmp LBB6_15, $-1092(%rip) -LBB9_70: - WORD $0x8944; BYTE $0xe0 // movl %r12d, %eax - WORD $0xe8c1; BYTE $0x0c // shrl $12, %eax - WORD $0xe00c // orb $-32, %al - WORD $0x8841; BYTE $0x06 // movb %al, (%r14) - WORD $0x8944; BYTE $0xe0 // movl %r12d, %eax - WORD $0xe8c1; BYTE $0x06 // shrl $6, %eax - WORD $0x3f24 // andb $63, %al - WORD $0x800c // orb $-128, %al - LONG $0x01468841 // movb %al, $1(%r14) - LONG $0x3fe48041 // andb $63, %r12b - LONG $0x80cc8041 // orb $-128, %r12b - LONG $0x02668845 // movb %r12b, $2(%r14) - LONG $0x03c68349 // addq $3, %r14 - -LBB9_56: - LONG $0xb8458b4c // movq $-72(%rbp), %r8 - LONG $0x6c258d4c; WORD $0x00e1; BYTE $0x00 // leaq $57708(%rip), %r12 /* __UnquoteTab(%rip) */ - WORD $0x854d; BYTE $0xed // testq %r13, %r13 - LONG $0xfbac850f; WORD $0xffff // jne LBB9_4, $-1108(%rip) - LONG $0x0002e0e9; BYTE $0x00 // jmp LBB9_37, $736(%rip) - -LBB9_110: - WORD $0xd889 // movl %ebx, %eax - -LBB9_85: - LONG $0x0ae4c141 // shll $10, %r12d - WORD $0xc189 // movl %eax, %ecx - WORD $0x0144; BYTE $0xe1 // addl %r12d, %ecx - WORD $0x0144; BYTE $0xe0 // addl %r12d, %eax - LONG $0xa0240005; BYTE $0xfc // addl $-56613888, %eax - WORD $0xc289 // movl %eax, %edx - WORD $0xeac1; BYTE $0x12 // shrl $18, %edx - WORD $0xc689 // movl %eax, %esi - WORD $0xeec1; BYTE $0x0c // shrl $12, %esi - LONG $0x3fe68040 // andb $63, %sil - WORD $0xe8c1; BYTE $0x06 // shrl $6, %eax - LONG $0xc26ef9c5 // vmovd %edx, %xmm0 - LONG $0xd6b60f40 // movzbl %sil, %edx - LONG $0x2079e3c4; WORD $0x01c2 // vpinsrb $1, %edx, %xmm0, %xmm0 - WORD $0x3f24 // andb $63, %al - WORD $0xb60f; BYTE $0xc0 // movzbl %al, %eax - LONG $0x2079e3c4; WORD $0x02c0 // vpinsrb $2, %eax, %xmm0, %xmm0 - WORD $0xe180; BYTE $0x3f // andb $63, %cl - WORD $0xb60f; BYTE $0xc1 // movzbl %cl, %eax - LONG $0x2079e3c4; WORD $0x03c0 // vpinsrb $3, %eax, %xmm0, %xmm0 - QUAD $0xfffffafd0d6ff9c5 // vmovdqa $-1283(%rip), %xmm1 /* LCPI9_1(%rip) */ - LONG $0xc1ebf9c5 // vpor %xmm1, %xmm0, %xmm0 - LONG $0x7e79c1c4; BYTE $0x06 // vmovd %xmm0, (%r14) - LONG $0x04c68349 // addq $4, %r14 - LONG $0xc07d8b48 // movq $-64(%rbp), %rdi - LONG $0xa0558b48 // movq $-96(%rbp), %rdx - LONG $0xa8558b4c // movq $-88(%rbp), %r10 - LONG $0xb0758b48 // movq $-80(%rbp), %rsi - LONG $0xb8458b4c // movq $-72(%rbp), %r8 - LONG $0xe5258d4c; WORD $0x00e0; BYTE $0x00 // leaq $57573(%rip), %r12 /* __UnquoteTab(%rip) */ - QUAD $0xfffffabd156ff9c5 // vmovdqa $-1347(%rip), %xmm2 /* LCPI9_0(%rip) */ - WORD $0x854d; BYTE $0xed // testq %r13, %r13 - LONG $0xfb1d850f; WORD $0xffff // jne LBB9_4, $-1251(%rip) - LONG $0x000251e9; BYTE $0x00 // jmp LBB9_37, $593(%rip) - -LBB9_66: - WORD $0x8949; BYTE $0xcd // movq %rcx, %r13 - WORD $0x8941; BYTE $0xdc // movl %ebx, %r12d - WORD $0x894d; BYTE $0xcf // movq %r9, %r15 - -LBB9_67: - WORD $0x8944; BYTE $0xe0 // movl %r12d, %eax - WORD $0xe8c1; BYTE $0x06 // shrl $6, %eax - WORD $0xc00c // orb $-64, %al - WORD $0x8841; BYTE $0x06 // movb %al, (%r14) - LONG $0x3fe48041 // andb $63, %r12b - LONG $0x80cc8041 // orb $-128, %r12b - LONG $0x01668845 // movb %r12b, $1(%r14) - LONG $0x02c68349 // addq $2, %r14 - LONG $0xffff2fe9; BYTE $0xff // jmp LBB9_56, $-209(%rip) - -LBB9_71: - WORD $0x8949; BYTE $0xdc // movq %rbx, %r12 - LONG $0x984d8948 // movq %rcx, $-104(%rbp) - LONG $0xc84d894c // movq %r9, $-56(%rbp) - LONG $0xb0758948 // movq %rsi, $-80(%rbp) - LONG $0xa0558948 // movq %rdx, $-96(%rbp) - LONG $0xc07d8948 // movq %rdi, $-64(%rbp) - LONG $0xa855894c // movq %r10, $-88(%rbp) - WORD $0x854d; BYTE $0xd2 // testq %r10, %r10 - LONG $0x00c7850f; WORD $0x0000 // jne LBB9_72, $199(%rip) - LONG $0x987d8348; BYTE $0x06 // cmpq $6, $-104(%rbp) - LONG $0x00ee820f; WORD $0x0000 // jb LBB9_76, $238(%rip) +LBB6_66: + LONG $0x04c18349 // addq $4, %r9 -LBB9_78: - LONG $0xfffc8141; WORD $0x00db; BYTE $0x00 // cmpl $56319, %r12d - LONG $0x00e1870f; WORD $0x0000 // ja LBB9_76, $225(%rip) - LONG $0xc8458b48 // movq $-56(%rbp), %rax - WORD $0x3880; BYTE $0x5c // cmpb $92, (%rax) - LONG $0x00d4850f; WORD $0x0000 // jne LBB9_76, $212(%rip) - LONG $0xc8458b48 // movq $-56(%rbp), %rax - LONG $0x75017880 // cmpb $117, $1(%rax) - LONG $0x00c6850f; WORD $0x0000 // jne LBB9_76, $198(%rip) - LONG $0xc8458b48 // movq $-56(%rbp), %rax - WORD $0x588b; BYTE $0x02 // movl $2(%rax), %ebx - WORD $0xdf89 // movl %ebx, %edi - LONG $0x000331e8; BYTE $0x00 // callq _unhex16_is, $817(%rip) - WORD $0xc084 // testb %al, %al - LONG $0x0221840f; WORD $0x0000 // je LBB9_82, $545(%rip) - WORD $0xcb0f // bswapl %ebx - WORD $0xd889 // movl %ebx, %eax - WORD $0xd0f7 // notl %eax - WORD $0xe8c1; BYTE $0x04 // shrl $4, %eax - LONG $0x01010125; BYTE $0x01 // andl $16843009, %eax - WORD $0x048d; BYTE $0xc0 // leal (%rax,%rax,8), %eax - LONG $0x0f0fe381; WORD $0x0f0f // andl $252645135, %ebx - WORD $0xc301 // addl %eax, %ebx - WORD $0xd889 // movl %ebx, %eax - WORD $0xe8c1; BYTE $0x04 // shrl $4, %eax - WORD $0xd809 // orl %ebx, %eax - WORD $0xb60f; BYTE $0xc8 // movzbl %al, %ecx - WORD $0xe8c1; BYTE $0x08 // shrl $8, %eax - LONG $0x00ff0025; BYTE $0x00 // andl $65280, %eax - LONG $0xc8458348; BYTE $0x06 // addq $6, $-56(%rbp) - WORD $0x148d; BYTE $0x08 // leal (%rax,%rcx), %edx - LONG $0x2000c281; WORD $0xffff // addl $-57344, %edx - LONG $0xfc00fa81; WORD $0xffff // cmpl $-1024, %edx - LONG $0x02ae820f; WORD $0x0000 // jb LBB9_98, $686(%rip) - WORD $0xc809 // orl %ecx, %eax - LONG $0x986d8b4c // movq $-104(%rbp), %r13 - LONG $0xfac58349 // addq $-6, %r13 - LONG $0xc87d8b4c // movq $-56(%rbp), %r15 - LONG $0xfffe85e9; BYTE $0xff // jmp LBB9_85, $-379(%rip) - -LBB9_96: +LBB6_67: + WORD $0x8844; BYTE $0x38 // movb %r15b, (%rax) + WORD $0xff48; BYTE $0xc0 // incq %rax + LONG $0xffff91e9; BYTE $0xff // jmp LBB6_56, $-111(%rip) + +LBB6_68: + LONG $0x214c8d4f; BYTE $0x04 // leaq $4(%r9,%r12), %r9 + WORD $0x8944; BYTE $0xf9 // movl %r15d, %ecx + WORD $0xe9c1; BYTE $0x06 // shrl $6, %ecx + WORD $0xc980; BYTE $0xc0 // orb $-64, %cl + WORD $0x0888 // movb %cl, (%rax) + LONG $0x3fe78041 // andb $63, %r15b + LONG $0x80cf8041 // orb $-128, %r15b + LONG $0x01788844 // movb %r15b, $1(%rax) + LONG $0x02c08348 // addq $2, %rax + LONG $0xffff6ce9; BYTE $0xff // jmp LBB6_56, $-148(%rip) + +LBB6_69: + LONG $0x214c8d4f; BYTE $0x04 // leaq $4(%r9,%r12), %r9 + LONG $0x00000fe9; BYTE $0x00 // jmp LBB6_71, $15(%rip) + +LBB6_70: + LONG $0x214c8d4f; BYTE $0x05 // leaq $5(%r9,%r12), %r9 + WORD $0x294d; BYTE $0xe5 // subq %r12, %r13 + LONG $0xfbc58349 // addq $-5, %r13 + WORD $0x894d; BYTE $0xee // movq %r13, %r14 + +LBB6_71: LONG $0x02b845f6 // testb $2, $-72(%rbp) - LONG $0x028d840f; WORD $0x0000 // je LBB9_97, $653(%rip) - LONG $0x06c74166; WORD $0xbfef // movw $-16401, (%r14) - LONG $0x0246c641; BYTE $0xbd // movb $-67, $2(%r14) - LONG $0x03c68349 // addq $3, %r14 - LONG $0xc07d8b48 // movq $-64(%rbp), %rdi - LONG $0xb0758b48 // movq $-80(%rbp), %rsi - LONG $0xfffe44e9; BYTE $0xff // jmp LBB9_56, $-444(%rip) + LONG $0x0308840f; WORD $0x0000 // je LBB6_117, $776(%rip) -LBB9_72: - LONG $0x05fd8349 // cmpq $5, %r13 - LONG $0x028a820f; WORD $0x0000 // jb LBB9_87, $650(%rip) - LONG $0xc8458b48 // movq $-56(%rbp), %rax - WORD $0x3880; BYTE $0x5c // cmpb $92, (%rax) - LONG $0x025e850f; WORD $0x0000 // jne LBB9_98, $606(%rip) - LONG $0xfbc58349 // addq $-5, %r13 - LONG $0x05c78349 // addq $5, %r15 - LONG $0x986d894c // movq %r13, $-104(%rbp) - LONG $0xc87d894c // movq %r15, $-56(%rbp) - LONG $0x987d8348; BYTE $0x06 // cmpq $6, $-104(%rbp) - LONG $0xff12830f; WORD $0xffff // jae LBB9_78, $-238(%rip) - -LBB9_76: - LONG $0xc87d8b4c // movq $-56(%rbp), %r15 - -LBB9_77: - LONG $0xa8458b48 // movq $-88(%rbp), %rax - LONG $0xc0450348 // addq $-64(%rbp), %rax - WORD $0x2949; BYTE $0xc7 // subq %rax, %r15 - LONG $0xfcc78349 // addq $-4, %r15 - LONG $0xd0458b48 // movq $-48(%rbp), %rax - WORD $0x894c; BYTE $0x38 // movq %r15, (%rax) - LONG $0xfcc6c749; WORD $0xffff; BYTE $0xff // movq $-4, %r14 - LONG $0x00000ce9; BYTE $0x00 // jmp LBB9_52, $12(%rip) +LBB6_72: + LONG $0xef00c766; BYTE $0xbf // movw $-16401, (%rax) + LONG $0xbd0240c6 // movb $-67, $2(%rax) + LONG $0xffff37e9; BYTE $0xff // jmp LBB6_55, $-201(%rip) -LBB9_1: +LBB6_73: + LONG $0x02b845f6 // testb $2, $-72(%rbp) + LONG $0x02fd840f; WORD $0x0000 // je LBB6_118, $765(%rip) + LONG $0x214c8d4f; BYTE $0x04 // leaq $4(%r9,%r12), %r9 + LONG $0xffffdee9; BYTE $0xff // jmp LBB6_72, $-34(%rip) + +LBB6_75: + LONG $0x214c8d4f; BYTE $0x0a // leaq $10(%r9,%r12), %r9 + WORD $0x294d; BYTE $0xe5 // subq %r12, %r13 + LONG $0xf6c58349 // addq $-10, %r13 + LONG $0x00000ce9; BYTE $0x00 // jmp LBB6_77, $12(%rip) + +LBB6_76: + LONG $0x214c8d4f; BYTE $0x0b // leaq $11(%r9,%r12), %r9 + WORD $0x294d; BYTE $0xe5 // subq %r12, %r13 + LONG $0xf5c58349 // addq $-11, %r13 + +LBB6_77: + LONG $0x0ae7c141 // shll $10, %r15d + QUAD $0xfca024001f8c8d41 // leal $-56613888(%r15,%rbx), %ecx + LONG $0x0000f981; WORD $0x0011 // cmpl $1114112, %ecx + LONG $0x001c820f; WORD $0x0000 // jb LBB6_80, $28(%rip) + LONG $0x02b845f6 // testb $2, $-72(%rbp) + LONG $0x0264840f; WORD $0x0000 // je LBB6_112, $612(%rip) + LONG $0xef00c766; BYTE $0xbf // movw $-16401, (%rax) + LONG $0xbd0240c6 // movb $-67, $2(%rax) + LONG $0x03c08348 // addq $3, %rax + LONG $0xfffed9e9; BYTE $0xff // jmp LBB6_57, $-295(%rip) + +LBB6_80: + WORD $0xce89 // movl %ecx, %esi + WORD $0xeec1; BYTE $0x12 // shrl $18, %esi + LONG $0xf0ce8040 // orb $-16, %sil + WORD $0x8840; BYTE $0x30 // movb %sil, (%rax) + WORD $0xce89 // movl %ecx, %esi + WORD $0xeec1; BYTE $0x0c // shrl $12, %esi + LONG $0x3fe68040 // andb $63, %sil + LONG $0x80ce8040 // orb $-128, %sil + LONG $0x01708840 // movb %sil, $1(%rax) + WORD $0xce89 // movl %ecx, %esi + WORD $0xeec1; BYTE $0x06 // shrl $6, %esi + LONG $0x3fe68040 // andb $63, %sil + LONG $0x80ce8040 // orb $-128, %sil + LONG $0x02708840 // movb %sil, $2(%rax) + WORD $0xe180; BYTE $0x3f // andb $63, %cl + WORD $0xc980; BYTE $0x80 // orb $-128, %cl + WORD $0x4888; BYTE $0x03 // movb %cl, $3(%rax) + LONG $0x04c08348 // addq $4, %rax + LONG $0xfffe99e9; BYTE $0xff // jmp LBB6_57, $-359(%rip) + +LBB6_81: WORD $0x3145; BYTE $0xed // xorl %r13d, %r13d - WORD $0x8949; BYTE $0xd6 // movq %rdx, %r14 + WORD $0x8948; BYTE $0xd0 // movq %rdx, %rax -LBB9_2: - WORD $0x014d; BYTE $0xee // addq %r13, %r14 - WORD $0x2949; BYTE $0xd6 // subq %rdx, %r14 +LBB6_82: + WORD $0x014c; BYTE $0xe8 // addq %r13, %rax + WORD $0x2948; BYTE $0xd0 // subq %rdx, %rax -LBB9_52: - WORD $0x894c; BYTE $0xf0 // movq %r14, %rax - LONG $0x48c48348 // addq $72, %rsp - BYTE $0x5b // popq %rbx - WORD $0x5c41 // popq %r12 - WORD $0x5d41 // popq %r13 - WORD $0x5e41 // popq %r14 - WORD $0x5f41 // popq %r15 - BYTE $0x5d // popq %rbp - BYTE $0xc3 // retq +LBB6_83: + LONG $0x28c48348 // addq $40, %rsp + BYTE $0x5b // popq %rbx + WORD $0x5c41 // popq %r12 + WORD $0x5d41 // popq %r13 + WORD $0x5e41 // popq %r14 + WORD $0x5f41 // popq %r15 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq -LBB9_43: - WORD $0x894c; BYTE $0xf8 // movq %r15, %rax - WORD $0x2948; BYTE $0xf8 // subq %rdi, %rax - LONG $0xd0758b48 // movq $-48(%rbp), %rsi - WORD $0x8948; BYTE $0x06 // movq %rax, (%rsi) - LONG $0x0fb60f41 // movzbl (%r15), %ecx - WORD $0x518d; BYTE $0xc6 // leal $-58(%rcx), %edx - LONG $0xfec6c749; WORD $0xffff; BYTE $0xff // movq $-2, %r14 - WORD $0xfa80; BYTE $0xf5 // cmpb $-11, %dl - LONG $0x000f870f; WORD $0x0000 // ja LBB9_45, $15(%rip) +LBB6_84: + WORD $0x894c; BYTE $0xca // movq %r9, %rdx + WORD $0x2948; BYTE $0xfa // subq %rdi, %rdx + LONG $0xc87d8b48 // movq $-56(%rbp), %rdi + WORD $0x8948; BYTE $0x17 // movq %rdx, (%rdi) + WORD $0x8a41; BYTE $0x09 // movb (%r9), %cl + WORD $0x718d; BYTE $0xd0 // leal $-48(%rcx), %esi + LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq $-2, %rax + LONG $0x0afe8040 // cmpb $10, %sil + LONG $0x000f820f; WORD $0x0000 // jb LBB6_86, $15(%rip) WORD $0xe180; BYTE $0xdf // andb $-33, %cl - WORD $0xc180; BYTE $0xb9 // addb $-71, %cl - WORD $0xf980; BYTE $0xfa // cmpb $-6, %cl - LONG $0xffbb820f; WORD $0xffff // jb LBB9_52, $-69(%rip) - -LBB9_45: - LONG $0x01488d48 // leaq $1(%rax), %rcx - WORD $0x8948; BYTE $0x0e // movq %rcx, (%rsi) - LONG $0x4fb60f41; BYTE $0x01 // movzbl $1(%r15), %ecx - WORD $0x518d; BYTE $0xc6 // leal $-58(%rcx), %edx - WORD $0xfa80; BYTE $0xf5 // cmpb $-11, %dl - LONG $0x000f870f; WORD $0x0000 // ja LBB9_47, $15(%rip) + WORD $0xc180; BYTE $0xbf // addb $-65, %cl + WORD $0xf980; BYTE $0x05 // cmpb $5, %cl + LONG $0xffbe870f; WORD $0xffff // ja LBB6_83, $-66(%rip) + +LBB6_86: + LONG $0x014a8d48 // leaq $1(%rdx), %rcx + WORD $0x8948; BYTE $0x0f // movq %rcx, (%rdi) + LONG $0x01498a41 // movb $1(%r9), %cl + WORD $0x718d; BYTE $0xd0 // leal $-48(%rcx), %esi + LONG $0x0afe8040 // cmpb $10, %sil + LONG $0x000f820f; WORD $0x0000 // jb LBB6_88, $15(%rip) WORD $0xe180; BYTE $0xdf // andb $-33, %cl - WORD $0xc180; BYTE $0xb9 // addb $-71, %cl - WORD $0xf980; BYTE $0xfa // cmpb $-6, %cl - LONG $0xff94820f; WORD $0xffff // jb LBB9_52, $-108(%rip) - -LBB9_47: - LONG $0x02488d48 // leaq $2(%rax), %rcx - WORD $0x8948; BYTE $0x0e // movq %rcx, (%rsi) - LONG $0x4fb60f41; BYTE $0x02 // movzbl $2(%r15), %ecx - WORD $0x518d; BYTE $0xc6 // leal $-58(%rcx), %edx - WORD $0xfa80; BYTE $0xf5 // cmpb $-11, %dl - LONG $0x000f870f; WORD $0x0000 // ja LBB9_49, $15(%rip) + WORD $0xc180; BYTE $0xbf // addb $-65, %cl + WORD $0xf980; BYTE $0x05 // cmpb $5, %cl + LONG $0xff97870f; WORD $0xffff // ja LBB6_83, $-105(%rip) + +LBB6_88: + LONG $0x024a8d48 // leaq $2(%rdx), %rcx + WORD $0x8948; BYTE $0x0f // movq %rcx, (%rdi) + LONG $0x02498a41 // movb $2(%r9), %cl + WORD $0x718d; BYTE $0xd0 // leal $-48(%rcx), %esi + LONG $0x0afe8040 // cmpb $10, %sil + LONG $0x000f820f; WORD $0x0000 // jb LBB6_90, $15(%rip) WORD $0xe180; BYTE $0xdf // andb $-33, %cl - WORD $0xc180; BYTE $0xb9 // addb $-71, %cl - WORD $0xf980; BYTE $0xfa // cmpb $-6, %cl - LONG $0xff6d820f; WORD $0xffff // jb LBB9_52, $-147(%rip) - -LBB9_49: - LONG $0x03488d48 // leaq $3(%rax), %rcx - WORD $0x8948; BYTE $0x0e // movq %rcx, (%rsi) - LONG $0x4fb60f41; BYTE $0x03 // movzbl $3(%r15), %ecx - WORD $0x518d; BYTE $0xc6 // leal $-58(%rcx), %edx - WORD $0xfa80; BYTE $0xf5 // cmpb $-11, %dl - LONG $0x000f870f; WORD $0x0000 // ja LBB9_51, $15(%rip) + WORD $0xc180; BYTE $0xbf // addb $-65, %cl + WORD $0xf980; BYTE $0x05 // cmpb $5, %cl + LONG $0xff70870f; WORD $0xffff // ja LBB6_83, $-144(%rip) + +LBB6_90: + LONG $0x034a8d48 // leaq $3(%rdx), %rcx + WORD $0x8948; BYTE $0x0f // movq %rcx, (%rdi) + LONG $0x03498a41 // movb $3(%r9), %cl + WORD $0x718d; BYTE $0xd0 // leal $-48(%rcx), %esi + LONG $0x0afe8040 // cmpb $10, %sil + LONG $0x000f820f; WORD $0x0000 // jb LBB6_92, $15(%rip) WORD $0xe180; BYTE $0xdf // andb $-33, %cl - WORD $0xc180; BYTE $0xb9 // addb $-71, %cl - WORD $0xf980; BYTE $0xfa // cmpb $-6, %cl - LONG $0xff46820f; WORD $0xffff // jb LBB9_52, $-186(%rip) + WORD $0xc180; BYTE $0xbf // addb $-65, %cl + WORD $0xf980; BYTE $0x05 // cmpb $5, %cl + LONG $0xff49870f; WORD $0xffff // ja LBB6_83, $-183(%rip) -LBB9_51: - LONG $0x04c08348 // addq $4, %rax - WORD $0x8948; BYTE $0x06 // movq %rax, (%rsi) - LONG $0xffff3ae9; BYTE $0xff // jmp LBB9_52, $-198(%rip) +LBB6_92: + LONG $0x04c28348 // addq $4, %rdx + WORD $0x8948; BYTE $0x17 // movq %rdx, (%rdi) + LONG $0xffff3de9; BYTE $0xff // jmp LBB6_83, $-195(%rip) -LBB9_19: - LONG $0xd0458b48 // movq $-48(%rbp), %rax - WORD $0x8948; BYTE $0x30 // movq %rsi, (%rax) - LONG $0xffc6c749; WORD $0xffff; BYTE $0xff // movq $-1, %r14 - LONG $0xffff27e9; BYTE $0xff // jmp LBB9_52, $-217(%rip) - -LBB9_37: - WORD $0x3145; BYTE $0xed // xorl %r13d, %r13d - LONG $0xffff19e9; BYTE $0xff // jmp LBB9_2, $-231(%rip) - -LBB9_34: +LBB6_93: WORD $0xf748; BYTE $0xd7 // notq %rdi - WORD $0x0149; BYTE $0xff // addq %rdi, %r15 - LONG $0xd0458b48 // movq $-48(%rbp), %rax - WORD $0x894c; BYTE $0x38 // movq %r15, (%rax) - LONG $0xfdc6c749; WORD $0xffff; BYTE $0xff // movq $-3, %r14 - LONG $0xffff06e9; BYTE $0xff // jmp LBB9_52, $-250(%rip) + WORD $0x0149; BYTE $0xf9 // addq %rdi, %r9 + LONG $0xc8458b48 // movq $-56(%rbp), %rax + WORD $0x894c; BYTE $0x08 // movq %r9, (%rax) + LONG $0xfdc0c748; WORD $0xffff; BYTE $0xff // movq $-3, %rax + LONG $0xffff24e9; BYTE $0xff // jmp LBB6_83, $-220(%rip) -LBB9_23: - WORD $0xf748; BYTE $0xd7 // notq %rdi - WORD $0x0149; BYTE $0xff // addq %rdi, %r15 +LBB6_94: + WORD $0xf748; BYTE $0xd7 // notq %rdi + WORD $0x0149; BYTE $0xf9 // addq %rdi, %r9 + LONG $0x0000dae9; BYTE $0x00 // jmp LBB6_107, $218(%rip) -LBB9_24: - LONG $0xd0458b48 // movq $-48(%rbp), %rax - WORD $0x894c; BYTE $0x38 // movq %r15, (%rax) - LONG $0xfec6c749; WORD $0xffff; BYTE $0xff // movq $-2, %r14 - LONG $0xfffeede9; BYTE $0xff // jmp LBB9_52, $-275(%rip) +LBB6_95: + LONG $0x21748d4b; BYTE $0x04 // leaq $4(%r9,%r12), %rsi + LONG $0x000005e9; BYTE $0x00 // jmp LBB6_97, $5(%rip) -LBB9_29: - WORD $0x2949; BYTE $0xff // subq %rdi, %r15 - WORD $0xff49; BYTE $0xc7 // incq %r15 - LONG $0xffffe2e9; BYTE $0xff // jmp LBB9_24, $-30(%rip) +LBB6_96: + LONG $0x21748d4b; BYTE $0x05 // leaq $5(%r9,%r12), %rsi -LBB9_63: - LONG $0x02b845f6 // testb $2, $-72(%rbp) - LONG $0x0108840f; WORD $0x0000 // je LBB9_87, $264(%rip) - LONG $0x06c74166; WORD $0xbfef // movw $-16401, (%r14) - LONG $0x0246c641; BYTE $0xbd // movb $-67, $2(%r14) - LONG $0x03c68349 // addq $3, %r14 - WORD $0x3145; BYTE $0xed // xorl %r13d, %r13d - LONG $0xfffebbe9; BYTE $0xff // jmp LBB9_2, $-325(%rip) - -LBB9_82: - LONG $0xc87d8b4c // movq $-56(%rbp), %r15 - -LBB9_100: - WORD $0x894c; BYTE $0xf8 // movq %r15, %rax - LONG $0xc0452b48 // subq $-64(%rbp), %rax - LONG $0x02c08348 // addq $2, %rax - LONG $0xd04d8b48 // movq $-48(%rbp), %rcx - WORD $0x8948; BYTE $0x01 // movq %rax, (%rcx) - LONG $0x4fb60f41; BYTE $0x02 // movzbl $2(%r15), %ecx - WORD $0x518d; BYTE $0xc6 // leal $-58(%rcx), %edx - LONG $0xfec6c749; WORD $0xffff; BYTE $0xff // movq $-2, %r14 - WORD $0xfa80; BYTE $0xf5 // cmpb $-11, %dl - LONG $0x000f870f; WORD $0x0000 // ja LBB9_102, $15(%rip) +LBB6_97: + WORD $0x8948; BYTE $0xf2 // movq %rsi, %rdx + WORD $0x2948; BYTE $0xfa // subq %rdi, %rdx + LONG $0x02c28348 // addq $2, %rdx + LONG $0xc8458b48 // movq $-56(%rbp), %rax + WORD $0x8948; BYTE $0x10 // movq %rdx, (%rax) + WORD $0x4e8a; BYTE $0x02 // movb $2(%rsi), %cl + WORD $0x798d; BYTE $0xd0 // leal $-48(%rcx), %edi + LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq $-2, %rax + LONG $0x0aff8040 // cmpb $10, %dil + LONG $0x000f820f; WORD $0x0000 // jb LBB6_99, $15(%rip) WORD $0xe180; BYTE $0xdf // andb $-33, %cl - WORD $0xc180; BYTE $0xb9 // addb $-71, %cl - WORD $0xf980; BYTE $0xfa // cmpb $-6, %cl - LONG $0xfe84820f; WORD $0xffff // jb LBB9_52, $-380(%rip) - -LBB9_102: - LONG $0x01488d48 // leaq $1(%rax), %rcx - LONG $0xd0558b48 // movq $-48(%rbp), %rdx - WORD $0x8948; BYTE $0x0a // movq %rcx, (%rdx) - LONG $0x4fb60f41; BYTE $0x03 // movzbl $3(%r15), %ecx - WORD $0x518d; BYTE $0xc6 // leal $-58(%rcx), %edx - WORD $0xfa80; BYTE $0xf5 // cmpb $-11, %dl - LONG $0x000f870f; WORD $0x0000 // ja LBB9_104, $15(%rip) + WORD $0xc180; BYTE $0xbf // addb $-65, %cl + WORD $0xf980; BYTE $0x05 // cmpb $5, %cl + LONG $0xfed3870f; WORD $0xffff // ja LBB6_83, $-301(%rip) + +LBB6_99: + LONG $0x014a8d48 // leaq $1(%rdx), %rcx + LONG $0xc87d8b48 // movq $-56(%rbp), %rdi + WORD $0x8948; BYTE $0x0f // movq %rcx, (%rdi) + WORD $0x4e8a; BYTE $0x03 // movb $3(%rsi), %cl + WORD $0x798d; BYTE $0xd0 // leal $-48(%rcx), %edi + LONG $0x0aff8040 // cmpb $10, %dil + LONG $0x000f820f; WORD $0x0000 // jb LBB6_101, $15(%rip) WORD $0xe180; BYTE $0xdf // andb $-33, %cl - WORD $0xc180; BYTE $0xb9 // addb $-71, %cl - WORD $0xf980; BYTE $0xfa // cmpb $-6, %cl - LONG $0xfe59820f; WORD $0xffff // jb LBB9_52, $-423(%rip) - -LBB9_104: - LONG $0x02488d48 // leaq $2(%rax), %rcx - LONG $0xd0558b48 // movq $-48(%rbp), %rdx - WORD $0x8948; BYTE $0x0a // movq %rcx, (%rdx) - LONG $0x4fb60f41; BYTE $0x04 // movzbl $4(%r15), %ecx - WORD $0x518d; BYTE $0xc6 // leal $-58(%rcx), %edx - WORD $0xfa80; BYTE $0xf5 // cmpb $-11, %dl - LONG $0x000f870f; WORD $0x0000 // ja LBB9_106, $15(%rip) + WORD $0xc180; BYTE $0xbf // addb $-65, %cl + WORD $0xf980; BYTE $0x05 // cmpb $5, %cl + LONG $0xfea9870f; WORD $0xffff // ja LBB6_83, $-343(%rip) + +LBB6_101: + LONG $0x024a8d48 // leaq $2(%rdx), %rcx + LONG $0xc87d8b48 // movq $-56(%rbp), %rdi + WORD $0x8948; BYTE $0x0f // movq %rcx, (%rdi) + WORD $0x4e8a; BYTE $0x04 // movb $4(%rsi), %cl + WORD $0x798d; BYTE $0xd0 // leal $-48(%rcx), %edi + LONG $0x0aff8040 // cmpb $10, %dil + LONG $0x000f820f; WORD $0x0000 // jb LBB6_103, $15(%rip) WORD $0xe180; BYTE $0xdf // andb $-33, %cl - WORD $0xc180; BYTE $0xb9 // addb $-71, %cl - WORD $0xf980; BYTE $0xfa // cmpb $-6, %cl - LONG $0xfe2e820f; WORD $0xffff // jb LBB9_52, $-466(%rip) - -LBB9_106: - LONG $0x03488d48 // leaq $3(%rax), %rcx - LONG $0xd0558b48 // movq $-48(%rbp), %rdx - WORD $0x8948; BYTE $0x0a // movq %rcx, (%rdx) - LONG $0x4fb60f41; BYTE $0x05 // movzbl $5(%r15), %ecx - WORD $0x518d; BYTE $0xc6 // leal $-58(%rcx), %edx - WORD $0xfa80; BYTE $0xf5 // cmpb $-11, %dl - LONG $0x000f870f; WORD $0x0000 // ja LBB9_108, $15(%rip) + WORD $0xc180; BYTE $0xbf // addb $-65, %cl + WORD $0xf980; BYTE $0x05 // cmpb $5, %cl + LONG $0xfe7f870f; WORD $0xffff // ja LBB6_83, $-385(%rip) + +LBB6_103: + LONG $0x034a8d48 // leaq $3(%rdx), %rcx + LONG $0xc87d8b48 // movq $-56(%rbp), %rdi + WORD $0x8948; BYTE $0x0f // movq %rcx, (%rdi) + WORD $0x4e8a; BYTE $0x05 // movb $5(%rsi), %cl + WORD $0x718d; BYTE $0xd0 // leal $-48(%rcx), %esi + LONG $0x0afe8040 // cmpb $10, %sil + LONG $0x000f820f; WORD $0x0000 // jb LBB6_105, $15(%rip) WORD $0xe180; BYTE $0xdf // andb $-33, %cl - WORD $0xc180; BYTE $0xb9 // addb $-71, %cl - WORD $0xf980; BYTE $0xfa // cmpb $-6, %cl - LONG $0xfe03820f; WORD $0xffff // jb LBB9_52, $-509(%rip) + WORD $0xc180; BYTE $0xbf // addb $-65, %cl + WORD $0xf980; BYTE $0x05 // cmpb $5, %cl + LONG $0xfe55870f; WORD $0xffff // ja LBB6_83, $-427(%rip) -LBB9_108: - LONG $0x04c08348 // addq $4, %rax - LONG $0xd04d8b48 // movq $-48(%rbp), %rcx - WORD $0x8948; BYTE $0x01 // movq %rax, (%rcx) - LONG $0xfffdf3e9; BYTE $0xff // jmp LBB9_52, $-525(%rip) +LBB6_105: + LONG $0x04c28348 // addq $4, %rdx + LONG $0xc84d8b48 // movq $-56(%rbp), %rcx + WORD $0x8948; BYTE $0x11 // movq %rdx, (%rcx) + LONG $0xfffe45e9; BYTE $0xff // jmp LBB6_83, $-443(%rip) -LBB9_97: - LONG $0xc87d894c // movq %r15, $-56(%rbp) +LBB6_106: + WORD $0x2949; BYTE $0xf9 // subq %rdi, %r9 + WORD $0xff49; BYTE $0xc1 // incq %r9 -LBB9_98: - LONG $0xc8658b4c // movq $-56(%rbp), %r12 - LONG $0xc0652b4c // subq $-64(%rbp), %r12 - LONG $0xfcc48349 // addq $-4, %r12 - LONG $0xd0458b48 // movq $-48(%rbp), %rax - WORD $0x894c; BYTE $0x20 // movq %r12, (%rax) - LONG $0xfcc6c749; WORD $0xffff; BYTE $0xff // movq $-4, %r14 - LONG $0xfffdd0e9; BYTE $0xff // jmp LBB9_52, $-560(%rip) +LBB6_107: + LONG $0xc8458b48 // movq $-56(%rbp), %rax + WORD $0x894c; BYTE $0x08 // movq %r9, (%rax) + LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq $-2, %rax + LONG $0xfffe2ce9; BYTE $0xff // jmp LBB6_83, $-468(%rip) -LBB9_87: - LONG $0xd0458b48 // movq $-48(%rbp), %rax - LONG $0xb04d8b48 // movq $-80(%rbp), %rcx - WORD $0x8948; BYTE $0x08 // movq %rcx, (%rax) - LONG $0xffc6c749; WORD $0xffff; BYTE $0xff // movq $-1, %r14 - LONG $0xfffdb9e9; BYTE $0xff // jmp LBB9_52, $-583(%rip) +LBB6_108: + LONG $0x02b845f6 // testb $2, $-72(%rbp) + LONG $0x0015840f; WORD $0x0000 // je LBB6_111, $21(%rip) + LONG $0xef00c766; BYTE $0xbf // movw $-16401, (%rax) + LONG $0xbd0240c6 // movb $-67, $2(%rax) + LONG $0x03c08348 // addq $3, %rax - // .p2align 4, 0x90 -_unhex16_is: - BYTE $0x55 // pushq %rbp - WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp - WORD $0xf889 // movl %edi, %eax - WORD $0xd0f7 // notl %eax - LONG $0xcfd08f8d; WORD $0xcfcf // leal $-808464432(%rdi), %ecx - LONG $0x80808025; BYTE $0x80 // andl $-2139062144, %eax - WORD $0xc885 // testl %ecx, %eax - LONG $0x0007840f; WORD $0x0000 // je LBB10_2, $7(%rip) - WORD $0xc031 // xorl %eax, %eax - WORD $0xb60f; BYTE $0xc0 // movzbl %al, %eax - BYTE $0x5d // popq %rbp - BYTE $0xc3 // retq +LBB6_110: + WORD $0x3145; BYTE $0xed // xorl %r13d, %r13d + LONG $0xfffe07e9; BYTE $0xff // jmp LBB6_82, $-505(%rip) -LBB10_2: - LONG $0x19198f8d; WORD $0x1919 // leal $421075225(%rdi), %ecx - WORD $0xf909 // orl %edi, %ecx - LONG $0x8080c1f7; WORD $0x8080 // testl $-2139062144, %ecx - LONG $0x0007840f; WORD $0x0000 // je LBB10_4, $7(%rip) - WORD $0xc031 // xorl %eax, %eax - WORD $0xb60f; BYTE $0xc0 // movzbl %al, %eax - BYTE $0x5d // popq %rbp - BYTE $0xc3 // retq +LBB6_111: + LONG $0xc8458b48 // movq $-56(%rbp), %rax + WORD $0x894c; BYTE $0x18 // movq %r11, (%rax) + LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax + LONG $0xfffdfae9; BYTE $0xff // jmp LBB6_83, $-518(%rip) -LBB10_4: - LONG $0x7f7fe781; WORD $0x7f7f // andl $2139062143, %edi - LONG $0xc0c0c0b9; BYTE $0xc0 // movl $-1061109568, %ecx - WORD $0xf929 // subl %edi, %ecx - LONG $0x4646978d; WORD $0x4646 // leal $1179010630(%rdi), %edx - WORD $0xc121 // andl %eax, %ecx - WORD $0xd185 // testl %edx, %ecx - LONG $0x0007840f; WORD $0x0000 // je LBB10_6, $7(%rip) - WORD $0xc031 // xorl %eax, %eax - WORD $0xb60f; BYTE $0xc0 // movzbl %al, %eax - BYTE $0x5d // popq %rbp - BYTE $0xc3 // retq +LBB6_112: + WORD $0x2949; BYTE $0xf9 // subq %rdi, %r9 + LONG $0xfcc18349 // addq $-4, %r9 -LBB10_6: - LONG $0xe0e0e0b9; BYTE $0xe0 // movl $-522133280, %ecx - WORD $0xf929 // subl %edi, %ecx - LONG $0x3939c781; WORD $0x3939 // addl $960051513, %edi - WORD $0xc821 // andl %ecx, %eax - WORD $0xf885 // testl %edi, %eax - WORD $0x940f; BYTE $0xc0 // sete %al - WORD $0xb60f; BYTE $0xc0 // movzbl %al, %eax - BYTE $0x5d // popq %rbp - BYTE $0xc3 // retq - LONG $0x00000000; WORD $0x0000 // .p2align 4, 0x00 +LBB6_113: + LONG $0xc8458b48 // movq $-56(%rbp), %rax + WORD $0x894c; BYTE $0x08 // movq %r9, (%rax) + LONG $0xfcc0c748; WORD $0xffff; BYTE $0xff // movq $-4, %rax + LONG $0xfffde0e9; BYTE $0xff // jmp LBB6_83, $-544(%rip) -LCPI11_0: +LBB6_114: + LONG $0x21448d4b; BYTE $0x0a // leaq $10(%r9,%r12), %rax + LONG $0x000005e9; BYTE $0x00 // jmp LBB6_116, $5(%rip) + +LBB6_115: + LONG $0x21448d4b; BYTE $0x0b // leaq $11(%r9,%r12), %rax + +LBB6_116: + WORD $0x2948; BYTE $0xf8 // subq %rdi, %rax + LONG $0xfcc08348 // addq $-4, %rax + LONG $0xc84d8b48 // movq $-56(%rbp), %rcx + WORD $0x8948; BYTE $0x01 // movq %rax, (%rcx) + LONG $0xfcc0c748; WORD $0xffff; BYTE $0xff // movq $-4, %rax + LONG $0xfffdb7e9; BYTE $0xff // jmp LBB6_83, $-585(%rip) + +LBB6_117: + LONG $0x3a448d49; BYTE $0x04 // leaq $4(%r10,%rdi), %rax + WORD $0x2949; BYTE $0xc1 // subq %rax, %r9 + LONG $0xffffb7e9; BYTE $0xff // jmp LBB6_113, $-73(%rip) + +LBB6_118: + WORD $0x014d; BYTE $0xe1 // addq %r12, %r9 + WORD $0x2949; BYTE $0xf9 // subq %rdi, %r9 + LONG $0xfffface9; BYTE $0xff // jmp LBB6_113, $-84(%rip) + QUAD $0x0000000000000000; WORD $0x0000 // .p2align 4, 0x00 + +LCPI7_0: QUAD $0x2626262626262626; QUAD $0x2626262626262626 // .space 16, '&&&&&&&&&&&&&&&&' -LCPI11_1: +LCPI7_1: QUAD $0xe2e2e2e2e2e2e2e2; QUAD $0xe2e2e2e2e2e2e2e2 // .space 16, '\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2' -LCPI11_2: +LCPI7_2: QUAD $0xfdfdfdfdfdfdfdfd; QUAD $0xfdfdfdfdfdfdfdfd // .space 16, '\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd' -LCPI11_3: +LCPI7_3: QUAD $0x3c3c3c3c3c3c3c3c; QUAD $0x3c3c3c3c3c3c3c3c // .space 16, '<<<<<<<<<<<<<<<<' // .p2align 4, 0x90 @@ -2847,71 +2537,71 @@ _html_escape: BYTE $0x53 // pushq %rbx LONG $0x10ec8348 // subq $16, %rsp LONG $0xc84d8948 // movq %rcx, $-56(%rbp) - WORD $0x8949; BYTE $0xd6 // movq %rdx, %r14 + WORD $0x8949; BYTE $0xd2 // movq %rdx, %r10 LONG $0xd0558948 // movq %rdx, $-48(%rbp) WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax WORD $0x8548; BYTE $0xf6 // testq %rsi, %rsi - LONG $0x04a18e0f; WORD $0x0000 // jle LBB11_70, $1185(%rip) + LONG $0x04618e0f; WORD $0x0000 // jle LBB7_67, $1121(%rip) LONG $0xc8458b48 // movq $-56(%rbp), %rax WORD $0x8b4c; BYTE $0x08 // movq (%rax), %r9 - QUAD $0xffffff89056ff9c5 // vmovdqa $-119(%rip), %xmm0 /* LCPI11_0(%rip) */ - QUAD $0xffffff910d6ff9c5 // vmovdqa $-111(%rip), %xmm1 /* LCPI11_1(%rip) */ - QUAD $0xffffff99156ff9c5 // vmovdqa $-103(%rip), %xmm2 /* LCPI11_2(%rip) */ - QUAD $0xffffffa11d6ff9c5 // vmovdqa $-95(%rip), %xmm3 /* LCPI11_3(%rip) */ - LONG $0xfa1d8d4c; WORD $0x00dc; BYTE $0x00 // leaq $56570(%rip), %r11 /* __HtmlQuoteTab(%rip) */ - WORD $0x8949; BYTE $0xfc // movq %rdi, %r12 - LONG $0xd0758b4c // movq $-48(%rbp), %r14 + QUAD $0xffffff89056ff9c5 // vmovdqa $-119(%rip), %xmm0 /* LCPI7_0(%rip) */ + QUAD $0xffffff910d6ff9c5 // vmovdqa $-111(%rip), %xmm1 /* LCPI7_1(%rip) */ + QUAD $0xffffff99156ff9c5 // vmovdqa $-103(%rip), %xmm2 /* LCPI7_2(%rip) */ + QUAD $0xffffffa11d6ff9c5 // vmovdqa $-95(%rip), %xmm3 /* LCPI7_3(%rip) */ + LONG $0x5a1d8d4c; WORD $0x00e2; BYTE $0x00 // leaq $57946(%rip), %r11 /* __HtmlQuoteTab(%rip) */ + WORD $0x8949; BYTE $0xff // movq %rdi, %r15 + LONG $0xd0558b4c // movq $-48(%rbp), %r10 WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 -LBB11_2: - WORD $0x854d; BYTE $0xc9 // testq %r9, %r9 - LONG $0x047e8e0f; WORD $0x0000 // jle LBB11_3, $1150(%rip) - LONG $0x10fe8348 // cmpq $16, %rsi - WORD $0x930f; BYTE $0xc0 // setae %al - WORD $0x894d; BYTE $0xcd // movq %r9, %r13 - WORD $0x894d; BYTE $0xf0 // movq %r14, %r8 - WORD $0x8948; BYTE $0xf3 // movq %rsi, %rbx - WORD $0x894d; BYTE $0xe7 // movq %r12, %r15 - LONG $0x10f98349 // cmpq $16, %r9 - LONG $0x007a820f; WORD $0x0000 // jb LBB11_12, $122(%rip) - LONG $0x10fe8348 // cmpq $16, %rsi - LONG $0x0070820f; WORD $0x0000 // jb LBB11_12, $112(%rip) - WORD $0x3145; BYTE $0xc0 // xorl %r8d, %r8d - WORD $0x8948; BYTE $0xf2 // movq %rsi, %rdx - WORD $0x894c; BYTE $0xc9 // movq %r9, %rcx - LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 - -LBB11_7: - LONG $0x6f7a81c4; WORD $0x0424 // vmovdqu (%r12,%r8), %xmm4 - LONG $0xe874d9c5 // vpcmpeqb %xmm0, %xmm4, %xmm5 - LONG $0xf174d9c5 // vpcmpeqb %xmm1, %xmm4, %xmm6 - LONG $0xedebc9c5 // vpor %xmm5, %xmm6, %xmm5 - LONG $0xf2dbd9c5 // vpand %xmm2, %xmm4, %xmm6 - LONG $0xf374c9c5 // vpcmpeqb %xmm3, %xmm6, %xmm6 - LONG $0xeeebd1c5 // vpor %xmm6, %xmm5, %xmm5 - LONG $0x7f7a81c4; WORD $0x0624 // vmovdqu %xmm4, (%r14,%r8) - LONG $0xc5d7f9c5 // vpmovmskb %xmm5, %eax - WORD $0xc085 // testl %eax, %eax - LONG $0x0150850f; WORD $0x0000 // jne LBB11_8, $336(%rip) - LONG $0xf05a8d48 // leaq $-16(%rdx), %rbx - LONG $0xf0698d4c // leaq $-16(%rcx), %r13 - LONG $0x10c08349 // addq $16, %r8 - LONG $0x20fa8348 // cmpq $32, %rdx - WORD $0x9d0f; BYTE $0xc0 // setge %al - LONG $0x00108c0f; WORD $0x0000 // jl LBB11_11, $16(%rip) - WORD $0x8948; BYTE $0xda // movq %rbx, %rdx - LONG $0x1ff98348 // cmpq $31, %rcx - WORD $0x894c; BYTE $0xe9 // movq %r13, %rcx - LONG $0xffa78f0f; WORD $0xffff // jg LBB11_7, $-89(%rip) +LBB7_2: + WORD $0x854d; BYTE $0xc9 // testq %r9, %r9 + LONG $0x043e8e0f; WORD $0x0000 // jle LBB7_3, $1086(%rip) + LONG $0x0ffe8348 // cmpq $15, %rsi + WORD $0x9f0f; BYTE $0xc3 // setg %bl + WORD $0x894d; BYTE $0xcc // movq %r9, %r12 + WORD $0x894d; BYTE $0xd0 // movq %r10, %r8 + WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax + WORD $0x894d; BYTE $0xfd // movq %r15, %r13 + LONG $0x10f98349 // cmpq $16, %r9 + LONG $0x008a8c0f; WORD $0x0000 // jl LBB7_11, $138(%rip) + LONG $0x10fe8348 // cmpq $16, %rsi + LONG $0x00808c0f; WORD $0x0000 // jl LBB7_11, $128(%rip) + WORD $0x894d; BYTE $0xfd // movq %r15, %r13 + WORD $0x8948; BYTE $0xf2 // movq %rsi, %rdx + WORD $0x894d; BYTE $0xd0 // movq %r10, %r8 + WORD $0x894c; BYTE $0xc9 // movq %r9, %rcx + LONG $0x90909090 // .p2align 4, 0x90 -LBB11_11: - LONG $0x043c8d4f // leaq (%r12,%r8), %r15 - WORD $0x014d; BYTE $0xf0 // addq %r14, %r8 +LBB7_7: + LONG $0x6f7ac1c4; WORD $0x0065 // vmovdqu (%r13), %xmm4 + LONG $0xe874d9c5 // vpcmpeqb %xmm0, %xmm4, %xmm5 + LONG $0xf174d9c5 // vpcmpeqb %xmm1, %xmm4, %xmm6 + LONG $0xedebc9c5 // vpor %xmm5, %xmm6, %xmm5 + LONG $0xf2dbd9c5 // vpand %xmm2, %xmm4, %xmm6 + LONG $0xf374c9c5 // vpcmpeqb %xmm3, %xmm6, %xmm6 + LONG $0xeeebd1c5 // vpor %xmm6, %xmm5, %xmm5 + LONG $0x7f7ac1c4; BYTE $0x20 // vmovdqu %xmm4, (%r8) + LONG $0xc5d7f9c5 // vpmovmskb %xmm5, %eax + WORD $0x8566; BYTE $0xc0 // testw %ax, %ax + LONG $0x0130850f; WORD $0x0000 // jne LBB7_8, $304(%rip) + LONG $0x10c58349 // addq $16, %r13 + LONG $0x10c08349 // addq $16, %r8 + LONG $0xf0428d48 // leaq $-16(%rdx), %rax + LONG $0xf0618d4c // leaq $-16(%rcx), %r12 + LONG $0x1ffa8348 // cmpq $31, %rdx + WORD $0x9f0f; BYTE $0xc3 // setg %bl + LONG $0x20fa8348 // cmpq $32, %rdx + LONG $0x001f8c0f; WORD $0x0000 // jl LBB7_11, $31(%rip) + WORD $0x8948; BYTE $0xc2 // movq %rax, %rdx + LONG $0x1ff98348 // cmpq $31, %rcx + WORD $0x894c; BYTE $0xe1 // movq %r12, %rcx + LONG $0xff9f8f0f; WORD $0xffff // jg LBB7_7, $-97(%rip) + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 -LBB11_12: - WORD $0xc084 // testb %al, %al - LONG $0x0068840f; WORD $0x0000 // je LBB11_13, $104(%rip) - LONG $0x6f7ac1c4; BYTE $0x27 // vmovdqu (%r15), %xmm4 +LBB7_11: + WORD $0xdb84 // testb %bl, %bl + LONG $0x0068840f; WORD $0x0000 // je LBB7_12, $104(%rip) + LONG $0x6f7ac1c4; WORD $0x0065 // vmovdqu (%r13), %xmm4 LONG $0xe874d9c5 // vpcmpeqb %xmm0, %xmm4, %xmm5 LONG $0xf174d9c5 // vpcmpeqb %xmm1, %xmm4, %xmm6 LONG $0xedebc9c5 // vpor %xmm5, %xmm6, %xmm5 @@ -2920,304 +2610,293 @@ LBB11_12: LONG $0xeeebd1c5 // vpor %xmm6, %xmm5, %xmm5 LONG $0xc5d7f9c5 // vpmovmskb %xmm5, %eax LONG $0x0100000d; BYTE $0x00 // orl $65536, %eax - LONG $0xd0bc0f44 // bsfl %eax, %r10d + LONG $0xf0bc0f44 // bsfl %eax, %r14d LONG $0x7ef9e1c4; BYTE $0xe0 // vmovq %xmm4, %rax - WORD $0x394d; BYTE $0xd5 // cmpq %r10, %r13 - LONG $0x00f98d0f; WORD $0x0000 // jge LBB11_24, $249(%rip) - LONG $0x08fd8349 // cmpq $8, %r13 - LONG $0x0132820f; WORD $0x0000 // jb LBB11_35, $306(%rip) + WORD $0x394d; BYTE $0xf4 // cmpq %r14, %r12 + LONG $0x00ca8d0f; WORD $0x0000 // jge LBB7_15, $202(%rip) + LONG $0x08fc8349 // cmpq $8, %r12 + LONG $0x00f0820f; WORD $0x0000 // jb LBB7_26, $240(%rip) WORD $0x8949; BYTE $0x00 // movq %rax, (%r8) - LONG $0x08578d4d // leaq $8(%r15), %r10 + LONG $0x08758d4d // leaq $8(%r13), %r14 LONG $0x08c08349 // addq $8, %r8 - LONG $0xf85d8d49 // leaq $-8(%r13), %rbx - LONG $0x04fb8348 // cmpq $4, %rbx - LONG $0x01298d0f; WORD $0x0000 // jge LBB11_38, $297(%rip) - LONG $0x000136e9; BYTE $0x00 // jmp LBB11_39, $310(%rip) - QUAD $0x9090909090909090 // .p2align 4, 0x90 + LONG $0x24448d49; BYTE $0xf8 // leaq $-8(%r12), %rax + LONG $0x04f88348 // cmpq $4, %rax + LONG $0x00e68d0f; WORD $0x0000 // jge LBB7_29, $230(%rip) + LONG $0x0000f3e9; BYTE $0x00 // jmp LBB7_30, $243(%rip) + LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 -LBB11_13: - WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx - LONG $0x00878e0f; WORD $0x0000 // jle LBB11_21, $135(%rip) - WORD $0x854d; BYTE $0xed // testq %r13, %r13 - LONG $0x007e8e0f; WORD $0x0000 // jle LBB11_21, $126(%rip) - WORD $0xd231 // xorl %edx, %edx - WORD $0xc031 // xorl %eax, %eax - QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90 +LBB7_12: + WORD $0x854d; BYTE $0xe4 // testq %r12, %r12 + LONG $0x01148e0f; WORD $0x0000 // jle LBB7_13, $276(%rip) + WORD $0x8948; BYTE $0xc1 // movq %rax, %rcx + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0x010b8e0f; WORD $0x0000 // jle LBB7_40, $267(%rip) + QUAD $0x9090909090909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 -LBB11_16: - LONG $0x1cb60f45; BYTE $0x17 // movzbl (%r15,%rdx), %r11d - LONG $0x3efb8349 // cmpq $62, %r11 - LONG $0x0014870f; WORD $0x0000 // ja LBB11_17, $20(%rip) +LBB7_36: + LONG $0x55b60f41; BYTE $0x00 // movzbl (%r13), %edx + LONG $0x3efa8348 // cmpq $62, %rdx + LONG $0x0014870f; WORD $0x0000 // ja LBB7_37, $20(%rip) QUAD $0x004000000000b948; WORD $0x5000 // movabsq $5764607797912141824, %rcx - LONG $0xd9a30f4c // btq %r11, %rcx - LONG $0x00ae820f; WORD $0x0000 // jb LBB11_45, $174(%rip) + LONG $0xd1a30f48 // btq %rdx, %rcx + LONG $0x0080820f; WORD $0x0000 // jb LBB7_42, $128(%rip) -LBB11_17: - LONG $0xe2fb8141; WORD $0x0000; BYTE $0x00 // cmpl $226, %r11d - LONG $0x00a1840f; WORD $0x0000 // je LBB11_45, $161(%rip) - LONG $0x03148d4c // leaq (%rbx,%rax), %r10 - LONG $0x101c8845 // movb %r11b, (%r8,%rdx) - LONG $0xff488d48 // leaq $-1(%rax), %rcx - LONG $0x02fa8349 // cmpq $2, %r10 - LONG $0x00138c0f; WORD $0x0000 // jl LBB11_20, $19(%rip) - WORD $0x014c; BYTE $0xe8 // addq %r13, %rax - WORD $0xff48; BYTE $0xc2 // incq %rdx - LONG $0x01f88348 // cmpq $1, %rax - WORD $0x8948; BYTE $0xc8 // movq %rcx, %rax - LONG $0xffa78f0f; WORD $0xffff // jg LBB11_16, $-89(%rip) - -LBB11_20: - WORD $0x2949; BYTE $0xcf // subq %rcx, %r15 - WORD $0x0148; BYTE $0xcb // addq %rcx, %rbx - LONG $0x5a1d8d4c; WORD $0x00db; BYTE $0x00 // leaq $56154(%rip), %r11 /* __HtmlQuoteTab(%rip) */ - QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90 - -LBB11_21: - WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx - LONG $0x0160840f; WORD $0x0000 // je LBB11_22, $352(%rip) - WORD $0xf749; BYTE $0xd7 // notq %r15 - WORD $0x014d; BYTE $0xe7 // addq %r12, %r15 - WORD $0x854d; BYTE $0xff // testq %r15, %r15 - LONG $0x0168890f; WORD $0x0000 // jns LBB11_49, $360(%rip) - LONG $0x000287e9; BYTE $0x00 // jmp LBB11_48, $647(%rip) +LBB7_37: + WORD $0xfa80; BYTE $0xe2 // cmpb $-30, %dl + LONG $0x0077840f; WORD $0x0000 // je LBB7_42, $119(%rip) + LONG $0xff488d48 // leaq $-1(%rax), %rcx + WORD $0xff49; BYTE $0xc5 // incq %r13 + WORD $0x8841; BYTE $0x10 // movb %dl, (%r8) + LONG $0x02f88348 // cmpq $2, %rax + LONG $0x00c08c0f; WORD $0x0000 // jl LBB7_40, $192(%rip) + LONG $0x24548d49; BYTE $0xff // leaq $-1(%r12), %rdx + WORD $0xff49; BYTE $0xc0 // incq %r8 + WORD $0x8948; BYTE $0xc8 // movq %rcx, %rax + LONG $0x01fc8349 // cmpq $1, %r12 + WORD $0x8949; BYTE $0xd4 // movq %rdx, %r12 + LONG $0xffa88f0f; WORD $0xffff // jg LBB7_36, $-88(%rip) + LONG $0x0000a3e9; BYTE $0x00 // jmp LBB7_40, $163(%rip) WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 -LBB11_8: - LONG $0xc0bc0f66 // bsfw %ax, %ax - LONG $0xf8b70f44 // movzwl %ax, %r15d - WORD $0x014d; BYTE $0xc7 // addq %r8, %r15 - WORD $0x854d; BYTE $0xff // testq %r15, %r15 - LONG $0x014c890f; WORD $0x0000 // jns LBB11_49, $332(%rip) - LONG $0x00026be9; BYTE $0x00 // jmp LBB11_48, $619(%rip) +LBB7_8: + WORD $0xb70f; BYTE $0xc0 // movzwl %ax, %eax + WORD $0x294d; BYTE $0xfd // subq %r15, %r13 + LONG $0xe0bc0f44 // bsfl %eax, %r12d + WORD $0x014d; BYTE $0xec // addq %r13, %r12 + WORD $0x854d; BYTE $0xe4 // testq %r12, %r12 + LONG $0x00f3890f; WORD $0x0000 // jns LBB7_46, $243(%rip) + LONG $0x000249e9; BYTE $0x00 // jmp LBB7_45, $585(%rip) -LBB11_24: - LONG $0x08fa8341 // cmpl $8, %r10d - LONG $0x008f820f; WORD $0x0000 // jb LBB11_25, $143(%rip) +LBB7_15: + LONG $0x08fe8341 // cmpl $8, %r14d + LONG $0x0095820f; WORD $0x0000 // jb LBB7_16, $149(%rip) WORD $0x8949; BYTE $0x00 // movq %rax, (%r8) - LONG $0x086f8d4d // leaq $8(%r15), %r13 + LONG $0x08658d4d // leaq $8(%r13), %r12 LONG $0x08c08349 // addq $8, %r8 - LONG $0xf85a8d49 // leaq $-8(%r10), %rbx - LONG $0x04fb8348 // cmpq $4, %rbx - LONG $0x0086830f; WORD $0x0000 // jae LBB11_28, $134(%rip) - LONG $0x000094e9; BYTE $0x00 // jmp LBB11_29, $148(%rip) + LONG $0xf8468d49 // leaq $-8(%r14), %rax + LONG $0x04f88348 // cmpq $4, %rax + LONG $0x008c8d0f; WORD $0x0000 // jge LBB7_19, $140(%rip) + LONG $0x00009ae9; BYTE $0x00 // jmp LBB7_20, $154(%rip) -LBB11_45: - WORD $0x294d; BYTE $0xe7 // subq %r12, %r15 - WORD $0x2949; BYTE $0xc7 // subq %rax, %r15 - LONG $0xe21d8d4c; WORD $0x00da; BYTE $0x00 // leaq $56034(%rip), %r11 /* __HtmlQuoteTab(%rip) */ - WORD $0x854d; BYTE $0xff // testq %r15, %r15 - LONG $0x0109890f; WORD $0x0000 // jns LBB11_49, $265(%rip) - LONG $0x000228e9; BYTE $0x00 // jmp LBB11_48, $552(%rip) +LBB7_42: + WORD $0x294d; BYTE $0xfd // subq %r15, %r13 + LONG $0x0000b2e9; BYTE $0x00 // jmp LBB7_43, $178(%rip) -LBB11_35: - WORD $0x894d; BYTE $0xfa // movq %r15, %r10 - WORD $0x894c; BYTE $0xeb // movq %r13, %rbx - LONG $0x04fb8348 // cmpq $4, %rbx - LONG $0x00128c0f; WORD $0x0000 // jl LBB11_39, $18(%rip) +LBB7_26: + WORD $0x894d; BYTE $0xee // movq %r13, %r14 + WORD $0x894c; BYTE $0xe0 // movq %r12, %rax + LONG $0x04f88348 // cmpq $4, %rax + LONG $0x00128c0f; WORD $0x0000 // jl LBB7_30, $18(%rip) -LBB11_38: - WORD $0x8b41; BYTE $0x02 // movl (%r10), %eax - WORD $0x8941; BYTE $0x00 // movl %eax, (%r8) - LONG $0x04c28349 // addq $4, %r10 +LBB7_29: + WORD $0x8b41; BYTE $0x0e // movl (%r14), %ecx + WORD $0x8941; BYTE $0x08 // movl %ecx, (%r8) + LONG $0x04c68349 // addq $4, %r14 LONG $0x04c08349 // addq $4, %r8 - LONG $0xfcc38348 // addq $-4, %rbx + LONG $0xfcc08348 // addq $-4, %rax -LBB11_39: - LONG $0x02fb8348 // cmpq $2, %rbx - LONG $0x007c830f; WORD $0x0000 // jae LBB11_40, $124(%rip) - WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx - LONG $0x0007840f; WORD $0x0000 // je LBB11_43, $7(%rip) +LBB7_30: + LONG $0x02f88348 // cmpq $2, %rax + LONG $0x015b830f; WORD $0x0000 // jae LBB7_31, $347(%rip) + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0x0006840f; WORD $0x0000 // je LBB7_34, $6(%rip) -LBB11_42: - LONG $0x02b60f41 // movzbl (%r10), %eax +LBB7_33: + WORD $0x8a41; BYTE $0x06 // movb (%r14), %al WORD $0x8841; BYTE $0x00 // movb %al, (%r8) -LBB11_43: - WORD $0x014d; BYTE $0xfd // addq %r15, %r13 - WORD $0xf749; BYTE $0xd5 // notq %r13 - WORD $0x014d; BYTE $0xe5 // addq %r12, %r13 - WORD $0x894d; BYTE $0xef // movq %r13, %r15 - WORD $0x854d; BYTE $0xff // testq %r15, %r15 - LONG $0x00b3890f; WORD $0x0000 // jns LBB11_49, $179(%rip) - LONG $0x0001d2e9; BYTE $0x00 // jmp LBB11_48, $466(%rip) +LBB7_34: + WORD $0x294d; BYTE $0xfc // subq %r15, %r12 + WORD $0x014d; BYTE $0xec // addq %r13, %r12 + WORD $0xf749; BYTE $0xd4 // notq %r12 + WORD $0x854d; BYTE $0xe4 // testq %r12, %r12 + LONG $0x0071890f; WORD $0x0000 // jns LBB7_46, $113(%rip) + LONG $0x0001c7e9; BYTE $0x00 // jmp LBB7_45, $455(%rip) -LBB11_25: - WORD $0x894d; BYTE $0xfd // movq %r15, %r13 - WORD $0x894c; BYTE $0xd3 // movq %r10, %rbx - LONG $0x04fb8348 // cmpq $4, %rbx - LONG $0x0013820f; WORD $0x0000 // jb LBB11_29, $19(%rip) +LBB7_13: + WORD $0x8948; BYTE $0xc1 // movq %rax, %rcx -LBB11_28: - LONG $0x00458b41 // movl (%r13), %eax - WORD $0x8941; BYTE $0x00 // movl %eax, (%r8) - LONG $0x04c58349 // addq $4, %r13 - LONG $0x04c08349 // addq $4, %r8 - LONG $0xfcc38348 // addq $-4, %rbx +LBB7_40: + WORD $0x294d; BYTE $0xfd // subq %r15, %r13 + WORD $0xf748; BYTE $0xd9 // negq %rcx + WORD $0x194d; BYTE $0xe4 // sbbq %r12, %r12 + WORD $0x314d; BYTE $0xec // xorq %r13, %r12 + WORD $0x854d; BYTE $0xe4 // testq %r12, %r12 + LONG $0x0054890f; WORD $0x0000 // jns LBB7_46, $84(%rip) + LONG $0x0001aae9; BYTE $0x00 // jmp LBB7_45, $426(%rip) -LBB11_29: - LONG $0x02fb8348 // cmpq $2, %rbx - LONG $0x0047830f; WORD $0x0000 // jae LBB11_30, $71(%rip) - WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx - LONG $0x0008840f; WORD $0x0000 // je LBB11_33, $8(%rip) +LBB7_16: + WORD $0x894d; BYTE $0xec // movq %r13, %r12 + WORD $0x894c; BYTE $0xf0 // movq %r14, %rax + LONG $0x04f88348 // cmpq $4, %rax + LONG $0x00138c0f; WORD $0x0000 // jl LBB7_20, $19(%rip) -LBB11_32: - LONG $0x45b60f41; BYTE $0x00 // movzbl (%r13), %eax - WORD $0x8841; BYTE $0x00 // movb %al, (%r8) +LBB7_19: + LONG $0x240c8b41 // movl (%r12), %ecx + WORD $0x8941; BYTE $0x08 // movl %ecx, (%r8) + LONG $0x04c48349 // addq $4, %r12 + LONG $0x04c08349 // addq $4, %r8 + LONG $0xfcc08348 // addq $-4, %rax -LBB11_33: - WORD $0x294d; BYTE $0xe7 // subq %r12, %r15 - WORD $0x014d; BYTE $0xd7 // addq %r10, %r15 - WORD $0x854d; BYTE $0xff // testq %r15, %r15 - LONG $0x0061890f; WORD $0x0000 // jns LBB11_49, $97(%rip) - LONG $0x000180e9; BYTE $0x00 // jmp LBB11_48, $384(%rip) +LBB7_20: + LONG $0x02f88348 // cmpq $2, %rax + LONG $0x010d830f; WORD $0x0000 // jae LBB7_21, $269(%rip) + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0x0007840f; WORD $0x0000 // je LBB7_24, $7(%rip) -LBB11_40: - LONG $0x02b70f41 // movzwl (%r10), %eax - LONG $0x00894166 // movw %ax, (%r8) - LONG $0x02c28349 // addq $2, %r10 - LONG $0x02c08349 // addq $2, %r8 - LONG $0xfec38348 // addq $-2, %rbx - WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx - LONG $0xff70850f; WORD $0xffff // jne LBB11_42, $-144(%rip) - LONG $0xffff72e9; BYTE $0xff // jmp LBB11_43, $-142(%rip) +LBB7_23: + LONG $0x24048a41 // movb (%r12), %al + WORD $0x8841; BYTE $0x00 // movb %al, (%r8) -LBB11_30: - LONG $0x45b70f41; BYTE $0x00 // movzwl (%r13), %eax - LONG $0x00894166 // movw %ax, (%r8) - LONG $0x02c58349 // addq $2, %r13 - LONG $0x02c08349 // addq $2, %r8 - LONG $0xfec38348 // addq $-2, %rbx - WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx - LONG $0xffa4850f; WORD $0xffff // jne LBB11_32, $-92(%rip) - LONG $0xffffa7e9; BYTE $0xff // jmp LBB11_33, $-89(%rip) +LBB7_24: + WORD $0x294d; BYTE $0xfd // subq %r15, %r13 + WORD $0x014d; BYTE $0xf5 // addq %r14, %r13 -LBB11_22: - WORD $0x294d; BYTE $0xe7 // subq %r12, %r15 - WORD $0x854d; BYTE $0xff // testq %r15, %r15 - LONG $0x012f880f; WORD $0x0000 // js LBB11_48, $303(%rip) - QUAD $0x9090909090909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 +LBB7_43: + WORD $0x894d; BYTE $0xec // movq %r13, %r12 + WORD $0x854d; BYTE $0xe4 // testq %r12, %r12 + LONG $0x015b880f; WORD $0x0000 // js LBB7_45, $347(%rip) -LBB11_49: - WORD $0x014d; BYTE $0xfc // addq %r15, %r12 - WORD $0x014d; BYTE $0xfe // addq %r15, %r14 - WORD $0x294c; BYTE $0xfe // subq %r15, %rsi - LONG $0x01378e0f; WORD $0x0000 // jle LBB11_50, $311(%rip) - WORD $0x294d; BYTE $0xf9 // subq %r15, %r9 - LONG $0x0cb60f41; BYTE $0x24 // movzbl (%r12), %ecx +LBB7_46: + WORD $0x014d; BYTE $0xe7 // addq %r12, %r15 + WORD $0x014d; BYTE $0xe2 // addq %r12, %r10 + WORD $0x294c; BYTE $0xe6 // subq %r12, %rsi + LONG $0x016e8e0f; WORD $0x0000 // jle LBB7_47, $366(%rip) + WORD $0x294d; BYTE $0xe1 // subq %r12, %r9 + WORD $0x8a41; BYTE $0x0f // movb (%r15), %cl WORD $0xf980; BYTE $0xe2 // cmpb $-30, %cl - LONG $0x00b3840f; WORD $0x0000 // je LBB11_53, $179(%rip) - WORD $0x894c; BYTE $0xe0 // movq %r12, %rax + LONG $0x00f0840f; WORD $0x0000 // je LBB7_50, $240(%rip) + WORD $0x894c; BYTE $0xf8 // movq %r15, %rax -LBB11_57: - WORD $0xb60f; BYTE $0xc9 // movzbl %cl, %ecx - LONG $0x04e1c148 // shlq $4, %rcx - LONG $0x19148b4a // movq (%rcx,%r11), %rdx - WORD $0x6348; BYTE $0xda // movslq %edx, %rbx - WORD $0x2949; BYTE $0xd9 // subq %rbx, %r9 - LONG $0x01228c0f; WORD $0x0000 // jl LBB11_58, $290(%rip) - LONG $0x20e2c148 // shlq $32, %rdx - LONG $0x19148d4e // leaq (%rcx,%r11), %r10 - LONG $0x08c28349 // addq $8, %r10 - QUAD $0x000300000001b948; WORD $0x0000 // movabsq $12884901889, %rcx - WORD $0x3948; BYTE $0xca // cmpq %rcx, %rdx - LONG $0x00278c0f; WORD $0x0000 // jl LBB11_62, $39(%rip) - WORD $0x8b41; BYTE $0x0a // movl (%r10), %ecx - WORD $0x8941; BYTE $0x0e // movl %ecx, (%r14) - LONG $0x04c28349 // addq $4, %r10 - LONG $0x04468d4d // leaq $4(%r14), %r8 - LONG $0xfc4b8d48 // leaq $-4(%rbx), %rcx - LONG $0x02f98348 // cmpq $2, %rcx - LONG $0x001b830f; WORD $0x0000 // jae LBB11_65, $27(%rip) - LONG $0x00002ae9; BYTE $0x00 // jmp LBB11_66, $42(%rip) - LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 +LBB7_54: + WORD $0xb60f; BYTE $0xd1 // movzbl %cl, %edx + LONG $0x04e2c148 // shlq $4, %rdx + LONG $0x1a0c8b4a // movq (%rdx,%r11), %rcx + WORD $0x634c; BYTE $0xe1 // movslq %ecx, %r12 + WORD $0x294d; BYTE $0xe1 // subq %r12, %r9 + LONG $0x015b8c0f; WORD $0x0000 // jl LBB7_55, $347(%rip) + LONG $0x20e1c148 // shlq $32, %rcx + LONG $0x1a748d4e; BYTE $0x08 // leaq $8(%rdx,%r11), %r14 + QUAD $0x000300000001bb48; WORD $0x0000 // movabsq $12884901889, %rbx + WORD $0x3948; BYTE $0xd9 // cmpq %rbx, %rcx + LONG $0x00238c0f; WORD $0x0000 // jl LBB7_59, $35(%rip) + WORD $0x8b41; BYTE $0x0e // movl (%r14), %ecx + WORD $0x8941; BYTE $0x0a // movl %ecx, (%r10) + LONG $0x1a748d4e; BYTE $0x0c // leaq $12(%rdx,%r11), %r14 + LONG $0x04428d4d // leaq $4(%r10), %r8 + LONG $0x24548d49; BYTE $0xfc // leaq $-4(%r12), %rdx + LONG $0x02fa8348 // cmpq $2, %rdx + LONG $0x0015830f; WORD $0x0000 // jae LBB7_62, $21(%rip) + LONG $0x000024e9; BYTE $0x00 // jmp LBB7_63, $36(%rip) -LBB11_62: - WORD $0x894d; BYTE $0xf0 // movq %r14, %r8 - WORD $0x8948; BYTE $0xd9 // movq %rbx, %rcx - LONG $0x02f98348 // cmpq $2, %rcx - LONG $0x0014820f; WORD $0x0000 // jb LBB11_66, $20(%rip) + // .p2align 4, 0x90 +LBB7_59: + WORD $0x894d; BYTE $0xd0 // movq %r10, %r8 + WORD $0x894c; BYTE $0xe2 // movq %r12, %rdx + LONG $0x02fa8348 // cmpq $2, %rdx + LONG $0x0014820f; WORD $0x0000 // jb LBB7_63, $20(%rip) -LBB11_65: - LONG $0x12b70f41 // movzwl (%r10), %edx - LONG $0x10894166 // movw %dx, (%r8) - LONG $0x02c28349 // addq $2, %r10 +LBB7_62: + LONG $0x0eb70f41 // movzwl (%r14), %ecx + LONG $0x08894166 // movw %cx, (%r8) + LONG $0x02c68349 // addq $2, %r14 LONG $0x02c08349 // addq $2, %r8 - LONG $0xfec18348 // addq $-2, %rcx + LONG $0xfec28348 // addq $-2, %rdx -LBB11_66: - WORD $0x8548; BYTE $0xc9 // testq %rcx, %rcx - LONG $0x0007840f; WORD $0x0000 // je LBB11_68, $7(%rip) - LONG $0x0ab60f41 // movzbl (%r10), %ecx +LBB7_63: + WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx + LONG $0x0006840f; WORD $0x0000 // je LBB7_65, $6(%rip) + WORD $0x8a41; BYTE $0x0e // movb (%r14), %cl WORD $0x8841; BYTE $0x08 // movb %cl, (%r8) -LBB11_68: - WORD $0x0149; BYTE $0xde // addq %rbx, %r14 +LBB7_65: + WORD $0x014d; BYTE $0xe2 // addq %r12, %r10 -LBB11_69: +LBB7_66: WORD $0xff48; BYTE $0xc0 // incq %rax LONG $0xff4e8d48 // leaq $-1(%rsi), %rcx - WORD $0x8949; BYTE $0xc4 // movq %rax, %r12 + WORD $0x8949; BYTE $0xc7 // movq %rax, %r15 LONG $0x01fe8348 // cmpq $1, %rsi WORD $0x8948; BYTE $0xce // movq %rcx, %rsi - LONG $0xfc12870f; WORD $0xffff // ja LBB11_2, $-1006(%rip) - LONG $0x000076e9; BYTE $0x00 // jmp LBB11_70, $118(%rip) + LONG $0xfc938f0f; WORD $0xffff // jg LBB7_2, $-877(%rip) + LONG $0x0000b7e9; BYTE $0x00 // jmp LBB7_67, $183(%rip) + +LBB7_31: + LONG $0x0eb70f41 // movzwl (%r14), %ecx + LONG $0x08894166 // movw %cx, (%r8) + LONG $0x02c68349 // addq $2, %r14 + LONG $0x02c08349 // addq $2, %r8 + LONG $0xfec08348 // addq $-2, %rax + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0xfe91850f; WORD $0xffff // jne LBB7_33, $-367(%rip) + LONG $0xfffe92e9; BYTE $0xff // jmp LBB7_34, $-366(%rip) + +LBB7_21: + LONG $0x0cb70f41; BYTE $0x24 // movzwl (%r12), %ecx + LONG $0x08894166 // movw %cx, (%r8) + LONG $0x02c48349 // addq $2, %r12 + LONG $0x02c08349 // addq $2, %r8 + LONG $0xfec08348 // addq $-2, %rax + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0xfede850f; WORD $0xffff // jne LBB7_23, $-290(%rip) + LONG $0xfffee0e9; BYTE $0xff // jmp LBB7_24, $-288(%rip) -LBB11_53: +LBB7_50: LONG $0x03fe8348 // cmpq $3, %rsi - LONG $0x002c820f; WORD $0x0000 // jb LBB11_59, $44(%rip) - LONG $0x247c8041; WORD $0x8001 // cmpb $-128, $1(%r12) - LONG $0x0020850f; WORD $0x0000 // jne LBB11_59, $32(%rip) - LONG $0x4cb60f41; WORD $0x0224 // movzbl $2(%r12), %ecx + LONG $0x00288c0f; WORD $0x0000 // jl LBB7_56, $40(%rip) + LONG $0x017f8041; BYTE $0x80 // cmpb $-128, $1(%r15) + LONG $0x001d850f; WORD $0x0000 // jne LBB7_56, $29(%rip) + LONG $0x024f8a41 // movb $2(%r15), %cl WORD $0xc889 // movl %ecx, %eax WORD $0xfe24 // andb $-2, %al WORD $0xa83c // cmpb $-88, %al - LONG $0x000e850f; WORD $0x0000 // jne LBB11_59, $14(%rip) - LONG $0x24448d49; BYTE $0x02 // leaq $2(%r12), %rax + LONG $0x000d850f; WORD $0x0000 // jne LBB7_56, $13(%rip) + LONG $0x02478d49 // leaq $2(%r15), %rax LONG $0xfec68348 // addq $-2, %rsi - LONG $0xffff1ae9; BYTE $0xff // jmp LBB11_57, $-230(%rip) + LONG $0xfffee1e9; BYTE $0xff // jmp LBB7_54, $-287(%rip) -LBB11_59: +LBB7_56: WORD $0x854d; BYTE $0xc9 // testq %r9, %r9 - LONG $0x00558e0f; WORD $0x0000 // jle LBB11_3, $85(%rip) - LONG $0xe206c641 // movb $-30, (%r14) - WORD $0xff49; BYTE $0xc6 // incq %r14 + LONG $0x00558e0f; WORD $0x0000 // jle LBB7_3, $85(%rip) + LONG $0xe202c641 // movb $-30, (%r10) + WORD $0xff49; BYTE $0xc2 // incq %r10 WORD $0xff49; BYTE $0xc9 // decq %r9 - WORD $0x894c; BYTE $0xe0 // movq %r12, %rax - LONG $0xffff93e9; BYTE $0xff // jmp LBB11_69, $-109(%rip) + WORD $0x894c; BYTE $0xf8 // movq %r15, %rax + LONG $0xffff52e9; BYTE $0xff // jmp LBB7_66, $-174(%rip) -LBB11_48: - LONG $0xd04d8b48 // movq $-48(%rbp), %rcx - WORD $0x014c; BYTE $0xf9 // addq %r15, %rcx - WORD $0xf748; BYTE $0xd1 // notq %rcx - WORD $0x014c; BYTE $0xf1 // addq %r14, %rcx - LONG $0xc8458b48 // movq $-56(%rbp), %rax - WORD $0x8948; BYTE $0x08 // movq %rcx, (%rax) - WORD $0x294c; BYTE $0xe7 // subq %r12, %rdi - WORD $0x014c; BYTE $0xff // addq %r15, %rdi +LBB7_45: + LONG $0xd0552b4c // subq $-48(%rbp), %r10 + WORD $0x894c; BYTE $0xe0 // movq %r12, %rax + WORD $0xf748; BYTE $0xd0 // notq %rax + WORD $0x014c; BYTE $0xd0 // addq %r10, %rax + LONG $0xc84d8b48 // movq $-56(%rbp), %rcx + WORD $0x8948; BYTE $0x01 // movq %rax, (%rcx) + WORD $0x294c; BYTE $0xff // subq %r15, %rdi + WORD $0x014c; BYTE $0xe7 // addq %r12, %rdi WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax - LONG $0x00002ae9; BYTE $0x00 // jmp LBB11_71, $42(%rip) + LONG $0x00002ae9; BYTE $0x00 // jmp LBB7_68, $42(%rip) -LBB11_50: - WORD $0x894c; BYTE $0xe0 // movq %r12, %rax +LBB7_47: + WORD $0x894c; BYTE $0xf8 // movq %r15, %rax -LBB11_70: - LONG $0xd0752b4c // subq $-48(%rbp), %r14 +LBB7_67: + LONG $0xd0552b4c // subq $-48(%rbp), %r10 LONG $0xc84d8b48 // movq $-56(%rbp), %rcx - WORD $0x894c; BYTE $0x31 // movq %r14, (%rcx) + WORD $0x894c; BYTE $0x11 // movq %r10, (%rcx) WORD $0x2948; BYTE $0xf8 // subq %rdi, %rax - LONG $0x000014e9; BYTE $0x00 // jmp LBB11_71, $20(%rip) + LONG $0x000014e9; BYTE $0x00 // jmp LBB7_68, $20(%rip) -LBB11_58: - LONG $0xd0752b4c // subq $-48(%rbp), %r14 +LBB7_55: + LONG $0xd0552b4c // subq $-48(%rbp), %r10 LONG $0xc8458b48 // movq $-56(%rbp), %rax - WORD $0x894c; BYTE $0x30 // movq %r14, (%rax) + WORD $0x894c; BYTE $0x10 // movq %r10, (%rax) -LBB11_3: - WORD $0xf749; BYTE $0xd4 // notq %r12 - WORD $0x0149; BYTE $0xfc // addq %rdi, %r12 - WORD $0x894c; BYTE $0xe0 // movq %r12, %rax +LBB7_3: + WORD $0xf749; BYTE $0xd7 // notq %r15 + WORD $0x0149; BYTE $0xff // addq %rdi, %r15 + WORD $0x894c; BYTE $0xf8 // movq %r15, %rax -LBB11_71: +LBB7_68: LONG $0x10c48348 // addq $16, %rsp BYTE $0x5b // popq %rbx WORD $0x5c41 // popq %r12 @@ -3233,145 +2912,119 @@ _atof_eisel_lemire64: WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp WORD $0x5741 // pushq %r15 WORD $0x5641 // pushq %r14 - WORD $0x5441 // pushq %r12 BYTE $0x53 // pushq %rbx - LONG $0xfea4868d; WORD $0xffff // leal $-348(%rsi), %eax - LONG $0xfffd483d; BYTE $0xff // cmpl $-696, %eax - LONG $0x0122820f; WORD $0x0000 // jb LBB12_1, $290(%rip) + LONG $0x015c868d; WORD $0x0000 // leal $348(%rsi), %eax + LONG $0x0002b73d; BYTE $0x00 // cmpl $695, %eax + LONG $0x0115870f; WORD $0x0000 // ja LBB8_1, $277(%rip) WORD $0x8949; BYTE $0xc8 // movq %rcx, %r8 WORD $0x8941; BYTE $0xd1 // movl %edx, %r9d WORD $0x8548; BYTE $0xff // testq %rdi, %rdi - LONG $0x000d840f; WORD $0x0000 // je LBB12_4, $13(%rip) + LONG $0x000d840f; WORD $0x0000 // je LBB8_4, $13(%rip) LONG $0xd7bd0f4c // bsrq %rdi, %r10 LONG $0x3ff28349 // xorq $63, %r10 - LONG $0x000006e9; BYTE $0x00 // jmp LBB12_5, $6(%rip) + LONG $0x000006e9; BYTE $0x00 // jmp LBB8_5, $6(%rip) -LBB12_4: +LBB8_4: LONG $0x0040ba41; WORD $0x0000 // movl $64, %r10d -LBB12_5: +LBB8_5: WORD $0x8944; BYTE $0xd1 // movl %r10d, %ecx WORD $0xd348; BYTE $0xe7 // shlq %cl, %rdi - LONG $0x015c8e8d; WORD $0x0000 // leal $348(%rsi), %ecx - LONG $0x04e1c148 // shlq $4, %rcx - LONG $0x4b258d4c; WORD $0x0062; BYTE $0x00 // leaq $25163(%rip), %r12 /* _POW10_M128_TAB(%rip) */ + WORD $0xc389 // movl %eax, %ebx + LONG $0x04e3c148 // shlq $4, %rbx + LONG $0xf1358d4c; WORD $0x0067; BYTE $0x00 // leaq $26609(%rip), %r14 /* _POW10_M128_TAB(%rip) */ WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax - LONG $0x2164f74a; BYTE $0x08 // mulq $8(%rcx,%r12) + LONG $0x3364f74a; BYTE $0x08 // mulq $8(%rbx,%r14) WORD $0x8949; BYTE $0xc7 // movq %rax, %r15 WORD $0x8949; BYTE $0xd3 // movq %rdx, %r11 - WORD $0x8944; BYTE $0xdb // movl %r11d, %ebx - LONG $0x01ffe381; WORD $0x0000 // andl $511, %ebx - LONG $0xfffb8148; WORD $0x0001; BYTE $0x00 // cmpq $511, %rbx - LONG $0x0050850f; WORD $0x0000 // jne LBB12_11, $80(%rip) - WORD $0x8949; BYTE $0xfe // movq %rdi, %r14 - WORD $0xf749; BYTE $0xd6 // notq %r14 + WORD $0x8944; BYTE $0xd8 // movl %r11d, %eax + LONG $0x0001ff25; BYTE $0x00 // andl $511, %eax + WORD $0x8948; BYTE $0xf9 // movq %rdi, %rcx + WORD $0xf748; BYTE $0xd1 // notq %rcx + WORD $0x3949; BYTE $0xcf // cmpq %rcx, %r15 + LONG $0x004f860f; WORD $0x0000 // jbe LBB8_11, $79(%rip) WORD $0x894c; BYTE $0xfa // movq %r15, %rdx - WORD $0x394d; BYTE $0xf7 // cmpq %r14, %r15 - LONG $0x0041860f; WORD $0x0000 // jbe LBB12_13, $65(%rip) + LONG $0x0001ff3d; BYTE $0x00 // cmpl $511, %eax + LONG $0x0044850f; WORD $0x0000 // jne LBB8_13, $68(%rip) WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax - LONG $0x2124f74a // mulq (%rcx,%r12) + LONG $0x3324f74a // mulq (%rbx,%r14) WORD $0x014c; BYTE $0xfa // addq %r15, %rdx LONG $0x00d38349 // adcq $0, %r11 - WORD $0x8944; BYTE $0xd9 // movl %r11d, %ecx - WORD $0xd1f7 // notl %ecx - LONG $0x37e1c148 // shlq $55, %rcx - LONG $0x0013850f; WORD $0x0000 // jne LBB12_12, $19(%rip) + WORD $0x3948; BYTE $0xc8 // cmpq %rcx, %rax + LONG $0x001d860f; WORD $0x0000 // jbe LBB8_12, $29(%rip) LONG $0xfffa8348 // cmpq $-1, %rdx - LONG $0x0009850f; WORD $0x0000 // jne LBB12_12, $9(%rip) - WORD $0x394c; BYTE $0xf0 // cmpq %r14, %rax - LONG $0x0083870f; WORD $0x0000 // ja LBB12_1, $131(%rip) - -LBB12_12: - WORD $0x8944; BYTE $0xdb // movl %r11d, %ebx - LONG $0x01ffe381; WORD $0x0000 // andl $511, %ebx - LONG $0x000003e9; BYTE $0x00 // jmp LBB12_13, $3(%rip) - -LBB12_11: + LONG $0x0013850f; WORD $0x0000 // jne LBB8_12, $19(%rip) + WORD $0x8944; BYTE $0xd8 // movl %r11d, %eax + LONG $0x0001ff25; BYTE $0x00 // andl $511, %eax + LONG $0x0001ff3d; BYTE $0x00 // cmpl $511, %eax + LONG $0x0079840f; WORD $0x0000 // je LBB8_1, $121(%rip) + +LBB8_12: + WORD $0x8944; BYTE $0xd8 // movl %r11d, %eax + LONG $0x0001ff25; BYTE $0x00 // andl $511, %eax + LONG $0x000003e9; BYTE $0x00 // jmp LBB8_13, $3(%rip) + +LBB8_11: WORD $0x894c; BYTE $0xfa // movq %r15, %rdx -LBB12_13: - WORD $0x894c; BYTE $0xd8 // movq %r11, %rax - LONG $0x3fe8c148 // shrq $63, %rax - WORD $0x488d; BYTE $0x09 // leal $9(%rax), %ecx +LBB8_13: + WORD $0x894c; BYTE $0xdf // movq %r11, %rdi + LONG $0x3fefc148 // shrq $63, %rdi + WORD $0x4f8d; BYTE $0x09 // leal $9(%rdi), %ecx WORD $0xd349; BYTE $0xeb // shrq %cl, %r11 - WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx - LONG $0x0018850f; WORD $0x0000 // jne LBB12_17, $24(%rip) - WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx - LONG $0x000f850f; WORD $0x0000 // jne LBB12_17, $15(%rip) - WORD $0x8944; BYTE $0xd9 // movl %r11d, %ecx - WORD $0xe183; BYTE $0x03 // andl $3, %ecx - WORD $0xf983; BYTE $0x01 // cmpl $1, %ecx - LONG $0x0044840f; WORD $0x0000 // je LBB12_1, $68(%rip) - -LBB12_17: - LONG $0x526ace69; WORD $0x0003 // imull $217706, %esi, %ecx - WORD $0xf9c1; BYTE $0x10 // sarl $16, %ecx - LONG $0x043fc181; WORD $0x0000 // addl $1087, %ecx - WORD $0x6348; BYTE $0xf1 // movslq %ecx, %rsi - WORD $0x294c; BYTE $0xd6 // subq %r10, %rsi - WORD $0x8944; BYTE $0xda // movl %r11d, %edx - WORD $0xe283; BYTE $0x01 // andl $1, %edx - WORD $0x014c; BYTE $0xda // addq %r11, %rdx - WORD $0x8948; BYTE $0xd1 // movq %rdx, %rcx - LONG $0x36e9c148 // shrq $54, %rcx - WORD $0x0148; BYTE $0xf0 // addq %rsi, %rax + WORD $0x0948; BYTE $0xd0 // orq %rdx, %rax + LONG $0x000f850f; WORD $0x0000 // jne LBB8_16, $15(%rip) + WORD $0x8944; BYTE $0xd8 // movl %r11d, %eax + WORD $0xe083; BYTE $0x03 // andl $3, %eax + WORD $0xf883; BYTE $0x01 // cmpl $1, %eax + LONG $0x0044840f; WORD $0x0000 // je LBB8_1, $68(%rip) + +LBB8_16: + LONG $0x526ac669; WORD $0x0003 // imull $217706, %esi, %eax + WORD $0xf8c1; BYTE $0x10 // sarl $16, %eax + LONG $0x00043f05; BYTE $0x00 // addl $1087, %eax + WORD $0x6348; BYTE $0xd0 // movslq %eax, %rdx + WORD $0x8944; BYTE $0xd8 // movl %r11d, %eax + WORD $0xe083; BYTE $0x01 // andl $1, %eax + WORD $0x014c; BYTE $0xd8 // addq %r11, %rax + QUAD $0x000000000000b948; WORD $0x01c0 // movabsq $126100789566373888, %rcx + WORD $0x2148; BYTE $0xc1 // andq %rax, %rcx + WORD $0x294c; BYTE $0xd2 // subq %r10, %rdx + LONG $0x3a548d48; BYTE $0xfe // leaq $-2(%rdx,%rdi), %rdx LONG $0x01f98348 // cmpq $1, %rcx - LONG $0x00d88348 // sbbq $0, %rax - LONG $0x01b08d48; WORD $0xfff8; BYTE $0xff // leaq $-2047(%rax), %rsi - LONG $0x02fe8148; WORD $0xfff8; BYTE $0xff // cmpq $-2046, %rsi - LONG $0x000b830f; WORD $0x0000 // jae LBB12_19, $11(%rip) + LONG $0xffda8348 // sbbq $-1, %rdx + LONG $0xfdfa8148; WORD $0x0007; BYTE $0x00 // cmpq $2045, %rdx + LONG $0x0009860f; WORD $0x0000 // jbe LBB8_18, $9(%rip) -LBB12_1: +LBB8_1: WORD $0xc031 // xorl %eax, %eax -LBB12_20: +LBB8_19: BYTE $0x5b // popq %rbx - WORD $0x5c41 // popq %r12 WORD $0x5e41 // popq %r14 WORD $0x5f41 // popq %r15 BYTE $0x5d // popq %rbp BYTE $0xc3 // retq -LBB12_19: +LBB8_18: + WORD $0xff48; BYTE $0xc2 // incq %rdx LONG $0x01f98348 // cmpq $1, %rcx WORD $0x02b1 // movb $2, %cl WORD $0xd980; BYTE $0x00 // sbbb $0, %cl - WORD $0xd348; BYTE $0xea // shrq %cl, %rdx - LONG $0x34e0c148 // shlq $52, %rax + WORD $0xd348; BYTE $0xe8 // shrq %cl, %rax + LONG $0x34e2c148 // shlq $52, %rdx QUAD $0xffffffffffffb948; WORD $0x000f // movabsq $4503599627370495, %rcx - WORD $0x2148; BYTE $0xd1 // andq %rdx, %rcx - WORD $0x0948; BYTE $0xc1 // orq %rax, %rcx + WORD $0x2148; BYTE $0xc1 // andq %rax, %rcx + WORD $0x0948; BYTE $0xd1 // orq %rdx, %rcx QUAD $0x000000000000b848; WORD $0x8000 // movabsq $-9223372036854775808, %rax WORD $0x0948; BYTE $0xc8 // orq %rcx, %rax LONG $0xfff98341 // cmpl $-1, %r9d LONG $0xc1450f48 // cmovneq %rcx, %rax WORD $0x8949; BYTE $0x00 // movq %rax, (%r8) WORD $0x01b0 // movb $1, %al - LONG $0xffffb8e9; BYTE $0xff // jmp LBB12_20, $-72(%rip) - QUAD $0x0000000000000000 // .p2align 5, 0x00 - -LCPI13_0: - QUAD $0x0000000000000000 // .space 8, '\x00\x00\x00\x00\x00\x00\x00\x00' - QUAD $0x0000000000000001 // .quad 1 - QUAD $0x0000000000000001 // .quad 1 - QUAD $0x0000000000000001 // .quad 1 - -LCPI13_1: - QUAD $0x0000000000000001 // .quad 1 - QUAD $0x0000000000000001 // .quad 1 - QUAD $0x0000000000000001 // .quad 1 - QUAD $0x0000000000000001 // .quad 1 - - // .p2align 4, 0x00 -LCPI13_2: - QUAD $0x0000000000002710 // .quad 10000 - QUAD $0x0000000000002710 // .quad 10000 - -LCPI13_3: - QUAD $0x000000000000000a // .quad 10 - QUAD $0x000000000000000a // .quad 10 + LONG $0xffffb7e9; BYTE $0xff // jmp LBB8_19, $-73(%rip) + LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 - // .p2align 4, 0x90 _decimal_to_f64: BYTE $0x55 // pushq %rbp WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp @@ -3385,479 +3038,262 @@ _decimal_to_f64: WORD $0x8949; BYTE $0xff // movq %rdi, %r15 QUAD $0x000000000000bd49; WORD $0x0010 // movabsq $4503599627370496, %r13 LONG $0x00107f83 // cmpl $0, $16(%rdi) - LONG $0x0021840f; WORD $0x0000 // je LBB13_3, $33(%rip) + LONG $0x002f840f; WORD $0x0000 // je LBB9_4, $47(%rip) + QUAD $0x000000000000be49; WORD $0x7ff0 // movabsq $9218868437227405312, %r14 LONG $0x14478b41 // movl $20(%r15), %eax - LONG $0x0001363d; BYTE $0x00 // cmpl $310, %eax - LONG $0x001d8e0f; WORD $0x0000 // jle LBB13_4, $29(%rip) - -LBB13_2: WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d - QUAD $0x000000000000be49; WORD $0x7ff0 // movabsq $9218868437227405312, %r14 - LONG $0x000706e9; BYTE $0x00 // jmp LBB13_74, $1798(%rip) + LONG $0x0001363d; BYTE $0x00 // cmpl $310, %eax + LONG $0x034c8f0f; WORD $0x0000 // jg LBB9_64, $844(%rip) + LONG $0xfffeb63d; BYTE $0xff // cmpl $-330, %eax + LONG $0x00138d0f; WORD $0x0000 // jge LBB9_5, $19(%rip) + WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d + LONG $0x000339e9; BYTE $0x00 // jmp LBB9_64, $825(%rip) -LBB13_3: +LBB9_4: WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d - LONG $0x0006fbe9; BYTE $0x00 // jmp LBB13_74, $1787(%rip) + LONG $0x00032ee9; BYTE $0x00 // jmp LBB9_64, $814(%rip) -LBB13_4: - WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d - LONG $0xfffeb63d; BYTE $0xff // cmpl $-330, %eax - LONG $0x00088d0f; WORD $0x0000 // jge LBB13_6, $8(%rip) - WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d - LONG $0x0006e5e9; BYTE $0x00 // jmp LBB13_74, $1765(%rip) - -LBB13_6: - WORD $0xc085 // testl %eax, %eax - LONG $0xd05d8948 // movq %rbx, $-48(%rbp) - LONG $0x00aa8e0f; WORD $0x0000 // jle LBB13_17, $170(%rip) - WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d - LONG $0xc0358d4c; WORD $0x008b; BYTE $0x00 // leaq $35776(%rip), %r14 /* _POW_TAB(%rip) */ - LONG $0x000039e9; BYTE $0x00 // jmp LBB13_11, $57(%rip) - QUAD $0x9090909090909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 +LBB9_5: + WORD $0xc085 // testl %eax, %eax + LONG $0xd05d8948 // movq %rbx, $-48(%rbp) + LONG $0x005a8e0f; WORD $0x0000 // jle LBB9_12, $90(%rip) + WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d + LONG $0xd8358d4c; WORD $0x0091; BYTE $0x00 // leaq $37336(%rip), %r14 /* _POW_TAB(%rip) */ + LONG $0x00002de9; BYTE $0x00 // jmp LBB9_8, $45(%rip) + WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 -LBB13_8: - LONG $0xffffe5be; BYTE $0xff // movl $-27, %esi - LONG $0x00001bbb; BYTE $0x00 // movl $27, %ebx +LBB9_10: + WORD $0xc089 // movl %eax, %eax + LONG $0x861c8b41 // movl (%r14,%rax,4), %ebx LONG $0x107f8341; BYTE $0x00 // cmpl $0, $16(%r15) - LONG $0x000a840f; WORD $0x0000 // je LBB13_10, $10(%rip) + LONG $0x000a840f; WORD $0x0000 // je LBB9_7, $10(%rip) -LBB13_9: - WORD $0xdef7 // negl %esi +LBB9_11: WORD $0x894c; BYTE $0xff // movq %r15, %rdi - LONG $0x0057a1e8; BYTE $0x00 // callq _right_shift, $22433(%rip) + WORD $0xde89 // movl %ebx, %esi + LONG $0x0060f5e8; BYTE $0x00 // callq _right_shift, $24821(%rip) -LBB13_10: +LBB9_7: WORD $0x0141; BYTE $0xdc // addl %ebx, %r12d LONG $0x14478b41 // movl $20(%r15), %eax WORD $0xc085 // testl %eax, %eax - LONG $0x00628e0f; WORD $0x0000 // jle LBB13_17, $98(%rip) + LONG $0x001e8e0f; WORD $0x0000 // jle LBB9_12, $30(%rip) -LBB13_11: +LBB9_8: WORD $0xf883; BYTE $0x08 // cmpl $8, %eax - LONG $0xffc9870f; WORD $0xffff // ja LBB13_8, $-55(%rip) - WORD $0xc089 // movl %eax, %eax - LONG $0x861c8b41 // movl (%r14,%rax,4), %ebx + LONG $0xffcd8e0f; WORD $0xffff // jle LBB9_10, $-51(%rip) + LONG $0x00001bbb; BYTE $0x00 // movl $27, %ebx LONG $0x107f8341; BYTE $0x00 // cmpl $0, $16(%r15) - LONG $0xffd7840f; WORD $0xffff // je LBB13_10, $-41(%rip) - WORD $0xde89 // movl %ebx, %esi - WORD $0xdef7 // negl %esi - WORD $0xfe83; BYTE $0xc3 // cmpl $-61, %esi - LONG $0xffc0870f; WORD $0xffff // ja LBB13_9, $-64(%rip) - WORD $0x894d; BYTE $0xf5 // movq %r14, %r13 - QUAD $0x9090909090909090 // .p2align 4, 0x90 - -LBB13_15: - WORD $0x8941; BYTE $0xf6 // movl %esi, %r14d - WORD $0x894c; BYTE $0xff // movq %r15, %rdi - LONG $0x00003cbe; BYTE $0x00 // movl $60, %esi - LONG $0x005750e8; BYTE $0x00 // callq _right_shift, $22352(%rip) - LONG $0x3c768d41 // leal $60(%r14), %esi - LONG $0x88fe8341 // cmpl $-120, %r14d - LONG $0xffe2820f; WORD $0xffff // jb LBB13_15, $-30(%rip) - WORD $0x894d; BYTE $0xee // movq %r13, %r14 - QUAD $0x000000000000bd49; WORD $0x0010 // movabsq $4503599627370496, %r13 - LONG $0xffff85e9; BYTE $0xff // jmp LBB13_9, $-123(%rip) + LONG $0xffce850f; WORD $0xffff // jne LBB9_11, $-50(%rip) + LONG $0xffffd3e9; BYTE $0xff // jmp LBB9_7, $-45(%rip) -LBB13_17: - LONG $0x19358d4c; WORD $0x008b; BYTE $0x00 // leaq $35609(%rip), %r14 /* _POW_TAB(%rip) */ - LONG $0x000025e9; BYTE $0x00 // jmp LBB13_19, $37(%rip) +LBB9_12: + LONG $0x81358d4c; WORD $0x0091; BYTE $0x00 // leaq $37249(%rip), %r14 /* _POW_TAB(%rip) */ + LONG $0x00002de9; BYTE $0x00 // jmp LBB9_14, $45(%rip) -LBB13_23: - LONG $0x00001bbb; BYTE $0x00 // movl $27, %ebx - LONG $0x107f8341; BYTE $0x00 // cmpl $0, $16(%r15) - LONG $0x0012840f; WORD $0x0000 // je LBB13_18, $18(%rip) - LONG $0x90909090 // .p2align 4, 0x90 +LBB9_18: + LONG $0x00001bbb; BYTE $0x00 // movl $27, %ebx + LONG $0x107f8341; BYTE $0x00 // cmpl $0, $16(%r15) + LONG $0x001a840f; WORD $0x0000 // je LBB9_13, $26(%rip) + QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90 -LBB13_25: +LBB9_20: WORD $0x894c; BYTE $0xff // movq %r15, %rdi WORD $0xde89 // movl %ebx, %esi - LONG $0x005516e8; BYTE $0x00 // callq _left_shift, $21782(%rip) + LONG $0x005ea6e8; BYTE $0x00 // callq _left_shift, $24230(%rip) LONG $0x14478b41 // movl $20(%r15), %eax -LBB13_18: +LBB9_13: WORD $0x2941; BYTE $0xdc // subl %ebx, %r12d -LBB13_19: +LBB9_14: WORD $0xc085 // testl %eax, %eax - LONG $0x0017880f; WORD $0x0000 // js LBB13_22, $23(%rip) - LONG $0x0032850f; WORD $0x0000 // jne LBB13_26, $50(%rip) + LONG $0x0017880f; WORD $0x0000 // js LBB9_17, $23(%rip) + LONG $0x0035850f; WORD $0x0000 // jne LBB9_21, $53(%rip) WORD $0x8b49; BYTE $0x0f // movq (%r15), %rcx WORD $0x3980; BYTE $0x35 // cmpb $53, (%rcx) - LONG $0x000e8c0f; WORD $0x0000 // jl LBB13_24, $14(%rip) - LONG $0x000021e9; BYTE $0x00 // jmp LBB13_26, $33(%rip) + LONG $0x000e8c0f; WORD $0x0000 // jl LBB9_19, $14(%rip) + LONG $0x000024e9; BYTE $0x00 // jmp LBB9_21, $36(%rip) // .p2align 4, 0x90 -LBB13_22: +LBB9_17: WORD $0xf883; BYTE $0xf8 // cmpl $-8, %eax - LONG $0xffb3820f; WORD $0xffff // jb LBB13_23, $-77(%rip) + LONG $0xffab8c0f; WORD $0xffff // jl LBB9_18, $-85(%rip) -LBB13_24: +LBB9_19: WORD $0xc189 // movl %eax, %ecx WORD $0xd9f7 // negl %ecx + WORD $0x6348; BYTE $0xc9 // movslq %ecx, %rcx LONG $0x8e1c8b41 // movl (%r14,%rcx,4), %ebx LONG $0x107f8341; BYTE $0x00 // cmpl $0, $16(%r15) - LONG $0xffb4850f; WORD $0xffff // jne LBB13_25, $-76(%rip) - LONG $0xffffbde9; BYTE $0xff // jmp LBB13_18, $-67(%rip) - -LBB13_26: - LONG $0x02fc8141; WORD $0xfffc; BYTE $0xff // cmpl $-1022, %r12d - LONG $0x00568f0f; WORD $0x0000 // jg LBB13_32, $86(%rip) - LONG $0x107f8341; BYTE $0x00 // cmpl $0, $16(%r15) - LONG $0xd05d8b48 // movq $-48(%rbp), %rbx - LONG $0x0075840f; WORD $0x0000 // je LBB13_35, $117(%rip) - LONG $0xc6fc8141; WORD $0xfffb; BYTE $0xff // cmpl $-1082, %r12d - LONG $0x0073870f; WORD $0x0000 // ja LBB13_36, $115(%rip) - LONG $0xc1c48141; WORD $0x0003; BYTE $0x00 // addl $961, %r12d - QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + LONG $0xffb1850f; WORD $0xffff // jne LBB9_20, $-79(%rip) + LONG $0xffffbae9; BYTE $0xff // jmp LBB9_13, $-70(%rip) -LBB13_30: +LBB9_21: + LONG $0x02fc8141; WORD $0xfffc; BYTE $0xff // cmpl $-1022, %r12d + LONG $0x00538f0f; WORD $0x0000 // jg LBB9_27, $83(%rip) + LONG $0x107f8341; BYTE $0x00 // cmpl $0, $16(%r15) + LONG $0xd05d8b48 // movq $-48(%rbp), %rbx + LONG $0x0060840f; WORD $0x0000 // je LBB9_29, $96(%rip) + LONG $0xc6fc8141; WORD $0xfffb; BYTE $0xff // cmpl $-1082, %r12d + LONG $0x005e8f0f; WORD $0x0000 // jg LBB9_30, $94(%rip) + LONG $0xc1c48141; WORD $0x0003; BYTE $0x00 // addl $961, %r12d + QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90 + +LBB9_25: WORD $0x894c; BYTE $0xff // movq %r15, %rdi LONG $0x00003cbe; BYTE $0x00 // movl $60, %esi - LONG $0x005673e8; BYTE $0x00 // callq _right_shift, $22131(%rip) + LONG $0x006003e8; BYTE $0x00 // callq _right_shift, $24579(%rip) LONG $0x3cc48341 // addl $60, %r12d LONG $0x88fc8341 // cmpl $-120, %r12d - LONG $0xffe5820f; WORD $0xffff // jb LBB13_30, $-27(%rip) + LONG $0xffe58c0f; WORD $0xffff // jl LBB9_25, $-27(%rip) LONG $0x3cc48341 // addl $60, %r12d - LONG $0x000040e9; BYTE $0x00 // jmp LBB13_37, $64(%rip) + LONG $0x00002ee9; BYTE $0x00 // jmp LBB9_31, $46(%rip) -LBB13_32: +LBB9_27: LONG $0x00fc8141; WORD $0x0004; BYTE $0x00 // cmpl $1024, %r12d LONG $0xd05d8b48 // movq $-48(%rbp), %rbx - QUAD $0x000000000000be49; WORD $0x7ff0 // movabsq $9218868437227405312, %r14 - LONG $0x00088e0f; WORD $0x0000 // jle LBB13_34, $8(%rip) - WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d - LONG $0x000538e9; BYTE $0x00 // jmp LBB13_74, $1336(%rip) - -LBB13_34: - WORD $0xff41; BYTE $0xcc // decl %r12d - WORD $0x8945; BYTE $0xe6 // movl %r12d, %r14d - LONG $0x000026e9; BYTE $0x00 // jmp LBB13_38, $38(%rip) + LONG $0x01a48f0f; WORD $0x0000 // jg LBB9_61, $420(%rip) + WORD $0xff41; BYTE $0xcc // decl %r12d + WORD $0x8945; BYTE $0xe6 // movl %r12d, %r14d + LONG $0x000026e9; BYTE $0x00 // jmp LBB9_32, $38(%rip) -LBB13_35: +LBB9_29: LONG $0xfc02be41; WORD $0xffff // movl $-1022, %r14d - LONG $0x000033e9; BYTE $0x00 // jmp LBB13_40, $51(%rip) + LONG $0x000033e9; BYTE $0x00 // jmp LBB9_34, $51(%rip) -LBB13_36: +LBB9_30: LONG $0xfdc48141; WORD $0x0003; BYTE $0x00 // addl $1021, %r12d -LBB13_37: +LBB9_31: WORD $0xf741; BYTE $0xdc // negl %r12d WORD $0x894c; BYTE $0xff // movq %r15, %rdi WORD $0x8944; BYTE $0xe6 // movl %r12d, %esi - LONG $0x00560ee8; BYTE $0x00 // callq _right_shift, $22030(%rip) + LONG $0x005fb0e8; BYTE $0x00 // callq _right_shift, $24496(%rip) LONG $0xfc02be41; WORD $0xffff // movl $-1022, %r14d -LBB13_38: +LBB9_32: LONG $0x107f8341; BYTE $0x00 // cmpl $0, $16(%r15) - LONG $0x000d840f; WORD $0x0000 // je LBB13_40, $13(%rip) + LONG $0x000d840f; WORD $0x0000 // je LBB9_34, $13(%rip) WORD $0x894c; BYTE $0xff // movq %r15, %rdi LONG $0x000035be; BYTE $0x00 // movl $53, %esi - LONG $0x005400e8; BYTE $0x00 // callq _left_shift, $21504(%rip) + LONG $0x005da2e8; BYTE $0x00 // callq _left_shift, $23970(%rip) -LBB13_40: +LBB9_34: LONG $0x14478b41 // movl $20(%r15), %eax LONG $0xffc4c749; WORD $0xffff; BYTE $0xff // movq $-1, %r12 WORD $0xf883; BYTE $0x14 // cmpl $20, %eax - LONG $0x04bc8f0f; WORD $0x0000 // jg LBB13_73, $1212(%rip) + LONG $0x015f8f0f; WORD $0x0000 // jg LBB9_63, $351(%rip) WORD $0xc085 // testl %eax, %eax - LONG $0x00558e0f; WORD $0x0000 // jle LBB13_46, $85(%rip) + LONG $0x00548e0f; WORD $0x0000 // jle LBB9_40, $84(%rip) LONG $0x10578b41 // movl $16(%r15), %edx WORD $0xf631 // xorl %esi, %esi WORD $0xd285 // testl %edx, %edx - WORD $0x4e0f; BYTE $0xd6 // cmovlel %esi, %edx + WORD $0x480f; BYTE $0xd6 // cmovsl %esi, %edx LONG $0xff488d4c // leaq $-1(%rax), %r9 WORD $0x3949; BYTE $0xd1 // cmpq %rdx, %r9 - LONG $0xca430f4c // cmovaeq %rdx, %r9 - LONG $0x01418d4d // leaq $1(%r9), %r8 + LONG $0xca430f44 // cmovael %edx, %r9d + LONG $0x01418d45 // leal $1(%r9), %r8d WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d - LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90 -LBB13_43: +LBB9_37: WORD $0x3948; BYTE $0xf2 // cmpq %rsi, %rdx - LONG $0x002e840f; WORD $0x0000 // je LBB13_47, $46(%rip) - LONG $0xa40c8d4b // leaq (%r12,%r12,4), %rcx - WORD $0x8b49; BYTE $0x3f // movq (%r15), %rdi - LONG $0x3cbe0f48; BYTE $0x37 // movsbq (%rdi,%rsi), %rdi - LONG $0x4f248d4c // leaq (%rdi,%rcx,2), %r12 - LONG $0xd0c48349 // addq $-48, %r12 + LONG $0x002b840f; WORD $0x0000 // je LBB9_41, $43(%rip) + LONG $0xa43c8d4b // leaq (%r12,%r12,4), %rdi + WORD $0x8b49; BYTE $0x0f // movq (%r15), %rcx + LONG $0x0cbe0f48; BYTE $0x31 // movsbq (%rcx,%rsi), %rcx + LONG $0x79648d4c; BYTE $0xd0 // leaq $-48(%rcx,%rdi,2), %r12 WORD $0xff48; BYTE $0xc6 // incq %rsi WORD $0x3948; BYTE $0xf0 // cmpq %rsi, %rax - LONG $0xffd7850f; WORD $0xffff // jne LBB13_43, $-41(%rip) - WORD $0x894d; BYTE $0xc1 // movq %r8, %r9 - LONG $0x000006e9; BYTE $0x00 // jmp LBB13_47, $6(%rip) + LONG $0xffda850f; WORD $0xffff // jne LBB9_37, $-38(%rip) + WORD $0x8945; BYTE $0xc1 // movl %r8d, %r9d + LONG $0x000006e9; BYTE $0x00 // jmp LBB9_41, $6(%rip) -LBB13_46: +LBB9_40: WORD $0x3145; BYTE $0xc9 // xorl %r9d, %r9d WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d -LBB13_47: +LBB9_41: WORD $0x3944; BYTE $0xc8 // cmpl %r9d, %eax - LONG $0x03cf8e0f; WORD $0x0000 // jle LBB13_60, $975(%rip) - WORD $0xc289 // movl %eax, %edx - WORD $0x2944; BYTE $0xca // subl %r9d, %edx - WORD $0xfa83; BYTE $0x10 // cmpl $16, %edx - LONG $0x03a0820f; WORD $0x0000 // jb LBB13_58, $928(%rip) - WORD $0x8941; BYTE $0xd0 // movl %edx, %r8d - QUAD $0xfffffca7056ff9c5 // vmovdqa $-857(%rip), %xmm0 /* LCPI13_0(%rip) */ - LONG $0x22f9c3c4; WORD $0x00c4 // vpinsrq $0, %r12, %xmm0, %xmm0 - QUAD $0xfffc970d0c7de3c4; WORD $0xf0ff // vblendps $240, $-873(%rip), %ymm0, %ymm1 /* LCPI13_0(%rip) */ - LONG $0xf0e08341 // andl $-16, %r8d - LONG $0xf0488d41 // leal $-16(%r8), %ecx - WORD $0xcf89 // movl %ecx, %edi - WORD $0xefc1; BYTE $0x04 // shrl $4, %edi - WORD $0xc7ff // incl %edi - WORD $0xfe89 // movl %edi, %esi - WORD $0xe683; BYTE $0x03 // andl $3, %esi - WORD $0xf983; BYTE $0x30 // cmpl $48, %ecx - LONG $0x0015830f; WORD $0x0000 // jae LBB13_51, $21(%rip) - QUAD $0xfffffc92156ffdc5 // vmovdqa $-878(%rip), %ymm2 /* LCPI13_1(%rip) */ - LONG $0xda6ffdc5 // vmovdqa %ymm2, %ymm3 - LONG $0xc26ffdc5 // vmovdqa %ymm2, %ymm0 - LONG $0x00010ee9; BYTE $0x00 // jmp LBB13_53, $270(%rip) - -LBB13_51: - WORD $0xe783; BYTE $0xfc // andl $-4, %edi - QUAD $0xfffffc7a156ffdc5 // vmovdqa $-902(%rip), %ymm2 /* LCPI13_1(%rip) */ - QUAD $0xfffffc92256ff9c5 // vmovdqa $-878(%rip), %xmm4 /* LCPI13_2(%rip) */ - LONG $0xda6ffdc5 // vmovdqa %ymm2, %ymm3 - LONG $0xc26ffdc5 // vmovdqa %ymm2, %ymm0 + LONG $0x00638e0f; WORD $0x0000 // jle LBB9_49, $99(%rip) + WORD $0xc689 // movl %eax, %esi + WORD $0x2944; BYTE $0xce // subl %r9d, %esi + WORD $0x8944; BYTE $0xca // movl %r9d, %edx + WORD $0xd2f7 // notl %edx + WORD $0xc201 // addl %eax, %edx + WORD $0xe683; BYTE $0x07 // andl $7, %esi + LONG $0x0022840f; WORD $0x0000 // je LBB9_46, $34(%rip) + WORD $0xdef7 // negl %esi + WORD $0xff31 // xorl %edi, %edi QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90 -LBB13_52: - LONG $0x197de3c4; WORD $0x01cd // vextractf128 $1, %ymm1, %xmm5 - LONG $0xf4f4d1c5 // vpmuludq %xmm4, %xmm5, %xmm6 - LONG $0xd573d1c5; BYTE $0x20 // vpsrlq $32, %xmm5, %xmm5 - LONG $0xecf4d1c5 // vpmuludq %xmm4, %xmm5, %xmm5 - LONG $0xf573d1c5; BYTE $0x20 // vpsllq $32, %xmm5, %xmm5 - LONG $0xedd4c9c5 // vpaddq %xmm5, %xmm6, %xmm5 - LONG $0xf4f4f1c5 // vpmuludq %xmm4, %xmm1, %xmm6 - LONG $0xd173f1c5; BYTE $0x20 // vpsrlq $32, %xmm1, %xmm1 - LONG $0xccf4f1c5 // vpmuludq %xmm4, %xmm1, %xmm1 - LONG $0xf173f1c5; BYTE $0x20 // vpsllq $32, %xmm1, %xmm1 - LONG $0xc9d4c9c5 // vpaddq %xmm1, %xmm6, %xmm1 - LONG $0x1875e3c4; WORD $0x01cd // vinsertf128 $1, %xmm5, %ymm1, %ymm1 - LONG $0x197de3c4; WORD $0x01d5 // vextractf128 $1, %ymm2, %xmm5 - LONG $0xf4f4d1c5 // vpmuludq %xmm4, %xmm5, %xmm6 - LONG $0xd573d1c5; BYTE $0x20 // vpsrlq $32, %xmm5, %xmm5 - LONG $0xecf4d1c5 // vpmuludq %xmm4, %xmm5, %xmm5 - LONG $0xf573d1c5; BYTE $0x20 // vpsllq $32, %xmm5, %xmm5 - LONG $0xedd4c9c5 // vpaddq %xmm5, %xmm6, %xmm5 - LONG $0xf4f4e9c5 // vpmuludq %xmm4, %xmm2, %xmm6 - LONG $0xd273e9c5; BYTE $0x20 // vpsrlq $32, %xmm2, %xmm2 - LONG $0xd4f4e9c5 // vpmuludq %xmm4, %xmm2, %xmm2 - LONG $0xf273e9c5; BYTE $0x20 // vpsllq $32, %xmm2, %xmm2 - LONG $0xd2d4c9c5 // vpaddq %xmm2, %xmm6, %xmm2 - LONG $0x186de3c4; WORD $0x01d5 // vinsertf128 $1, %xmm5, %ymm2, %ymm2 - LONG $0x197de3c4; WORD $0x01dd // vextractf128 $1, %ymm3, %xmm5 - LONG $0xf4f4d1c5 // vpmuludq %xmm4, %xmm5, %xmm6 - LONG $0xd573d1c5; BYTE $0x20 // vpsrlq $32, %xmm5, %xmm5 - LONG $0xecf4d1c5 // vpmuludq %xmm4, %xmm5, %xmm5 - LONG $0xf573d1c5; BYTE $0x20 // vpsllq $32, %xmm5, %xmm5 - LONG $0xedd4c9c5 // vpaddq %xmm5, %xmm6, %xmm5 - LONG $0xf4f4e1c5 // vpmuludq %xmm4, %xmm3, %xmm6 - LONG $0xd373e1c5; BYTE $0x20 // vpsrlq $32, %xmm3, %xmm3 - LONG $0xdcf4e1c5 // vpmuludq %xmm4, %xmm3, %xmm3 - LONG $0xf373e1c5; BYTE $0x20 // vpsllq $32, %xmm3, %xmm3 - LONG $0xdbd4c9c5 // vpaddq %xmm3, %xmm6, %xmm3 - LONG $0x1865e3c4; WORD $0x01dd // vinsertf128 $1, %xmm5, %ymm3, %ymm3 - LONG $0x197de3c4; WORD $0x01c5 // vextractf128 $1, %ymm0, %xmm5 - LONG $0xf4f4d1c5 // vpmuludq %xmm4, %xmm5, %xmm6 - LONG $0xd573d1c5; BYTE $0x20 // vpsrlq $32, %xmm5, %xmm5 - LONG $0xecf4d1c5 // vpmuludq %xmm4, %xmm5, %xmm5 - LONG $0xf573d1c5; BYTE $0x20 // vpsllq $32, %xmm5, %xmm5 - LONG $0xedd4c9c5 // vpaddq %xmm5, %xmm6, %xmm5 - LONG $0xf4f4f9c5 // vpmuludq %xmm4, %xmm0, %xmm6 - LONG $0xd073f9c5; BYTE $0x20 // vpsrlq $32, %xmm0, %xmm0 - LONG $0xc4f4f9c5 // vpmuludq %xmm4, %xmm0, %xmm0 - LONG $0xf073f9c5; BYTE $0x20 // vpsllq $32, %xmm0, %xmm0 - LONG $0xc0d4c9c5 // vpaddq %xmm0, %xmm6, %xmm0 - LONG $0x187de3c4; WORD $0x01c5 // vinsertf128 $1, %xmm5, %ymm0, %ymm0 - WORD $0xc783; BYTE $0xfc // addl $-4, %edi - LONG $0xff17850f; WORD $0xffff // jne LBB13_52, $-233(%rip) - -LBB13_53: - WORD $0xf685 // testl %esi, %esi - LONG $0x00f7840f; WORD $0x0000 // je LBB13_56, $247(%rip) - QUAD $0xfffffb97256ff9c5 // vmovdqa $-1129(%rip), %xmm4 /* LCPI13_3(%rip) */ - LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 - -LBB13_55: - LONG $0x197de3c4; WORD $0x01cd // vextractf128 $1, %ymm1, %xmm5 - LONG $0xf4f4d1c5 // vpmuludq %xmm4, %xmm5, %xmm6 - LONG $0xd573d1c5; BYTE $0x20 // vpsrlq $32, %xmm5, %xmm5 - LONG $0xecf4d1c5 // vpmuludq %xmm4, %xmm5, %xmm5 - LONG $0xf573d1c5; BYTE $0x20 // vpsllq $32, %xmm5, %xmm5 - LONG $0xedd4c9c5 // vpaddq %xmm5, %xmm6, %xmm5 - LONG $0xf4f4f1c5 // vpmuludq %xmm4, %xmm1, %xmm6 - LONG $0xd173f1c5; BYTE $0x20 // vpsrlq $32, %xmm1, %xmm1 - LONG $0xccf4f1c5 // vpmuludq %xmm4, %xmm1, %xmm1 - LONG $0xf173f1c5; BYTE $0x20 // vpsllq $32, %xmm1, %xmm1 - LONG $0xc9d4c9c5 // vpaddq %xmm1, %xmm6, %xmm1 - LONG $0x1875e3c4; WORD $0x01cd // vinsertf128 $1, %xmm5, %ymm1, %ymm1 - LONG $0x197de3c4; WORD $0x01d5 // vextractf128 $1, %ymm2, %xmm5 - LONG $0xf4f4d1c5 // vpmuludq %xmm4, %xmm5, %xmm6 - LONG $0xd573d1c5; BYTE $0x20 // vpsrlq $32, %xmm5, %xmm5 - LONG $0xecf4d1c5 // vpmuludq %xmm4, %xmm5, %xmm5 - LONG $0xf573d1c5; BYTE $0x20 // vpsllq $32, %xmm5, %xmm5 - LONG $0xedd4c9c5 // vpaddq %xmm5, %xmm6, %xmm5 - LONG $0xf4f4e9c5 // vpmuludq %xmm4, %xmm2, %xmm6 - LONG $0xd273e9c5; BYTE $0x20 // vpsrlq $32, %xmm2, %xmm2 - LONG $0xd4f4e9c5 // vpmuludq %xmm4, %xmm2, %xmm2 - LONG $0xf273e9c5; BYTE $0x20 // vpsllq $32, %xmm2, %xmm2 - LONG $0xd2d4c9c5 // vpaddq %xmm2, %xmm6, %xmm2 - LONG $0x186de3c4; WORD $0x01d5 // vinsertf128 $1, %xmm5, %ymm2, %ymm2 - LONG $0x197de3c4; WORD $0x01dd // vextractf128 $1, %ymm3, %xmm5 - LONG $0xf4f4d1c5 // vpmuludq %xmm4, %xmm5, %xmm6 - LONG $0xd573d1c5; BYTE $0x20 // vpsrlq $32, %xmm5, %xmm5 - LONG $0xecf4d1c5 // vpmuludq %xmm4, %xmm5, %xmm5 - LONG $0xf573d1c5; BYTE $0x20 // vpsllq $32, %xmm5, %xmm5 - LONG $0xedd4c9c5 // vpaddq %xmm5, %xmm6, %xmm5 - LONG $0xf4f4e1c5 // vpmuludq %xmm4, %xmm3, %xmm6 - LONG $0xd373e1c5; BYTE $0x20 // vpsrlq $32, %xmm3, %xmm3 - LONG $0xdcf4e1c5 // vpmuludq %xmm4, %xmm3, %xmm3 - LONG $0xf373e1c5; BYTE $0x20 // vpsllq $32, %xmm3, %xmm3 - LONG $0xdbd4c9c5 // vpaddq %xmm3, %xmm6, %xmm3 - LONG $0x1865e3c4; WORD $0x01dd // vinsertf128 $1, %xmm5, %ymm3, %ymm3 - LONG $0x197de3c4; WORD $0x01c5 // vextractf128 $1, %ymm0, %xmm5 - LONG $0xf4f4d1c5 // vpmuludq %xmm4, %xmm5, %xmm6 - LONG $0xd573d1c5; BYTE $0x20 // vpsrlq $32, %xmm5, %xmm5 - LONG $0xecf4d1c5 // vpmuludq %xmm4, %xmm5, %xmm5 - LONG $0xf573d1c5; BYTE $0x20 // vpsllq $32, %xmm5, %xmm5 - LONG $0xedd4c9c5 // vpaddq %xmm5, %xmm6, %xmm5 - LONG $0xf4f4f9c5 // vpmuludq %xmm4, %xmm0, %xmm6 - LONG $0xd073f9c5; BYTE $0x20 // vpsrlq $32, %xmm0, %xmm0 - LONG $0xc4f4f9c5 // vpmuludq %xmm4, %xmm0, %xmm0 - LONG $0xf073f9c5; BYTE $0x20 // vpsllq $32, %xmm0, %xmm0 - LONG $0xc0d4c9c5 // vpaddq %xmm0, %xmm6, %xmm0 - LONG $0x187de3c4; WORD $0x01c5 // vinsertf128 $1, %xmm5, %ymm0, %ymm0 - WORD $0xceff // decl %esi - LONG $0xff18850f; WORD $0xffff // jne LBB13_55, $-232(%rip) - -LBB13_56: - LONG $0x197de3c4; WORD $0x01cc // vextractf128 $1, %ymm1, %xmm4 - LONG $0x197de3c4; WORD $0x01d5 // vextractf128 $1, %ymm2, %xmm5 - LONG $0xd573c9c5; BYTE $0x20 // vpsrlq $32, %xmm5, %xmm6 - LONG $0xf4f4c9c5 // vpmuludq %xmm4, %xmm6, %xmm6 - LONG $0xd473c1c5; BYTE $0x20 // vpsrlq $32, %xmm4, %xmm7 - LONG $0xfff4d1c5 // vpmuludq %xmm7, %xmm5, %xmm7 - LONG $0xf6d4c1c5 // vpaddq %xmm6, %xmm7, %xmm6 - LONG $0xf673c9c5; BYTE $0x20 // vpsllq $32, %xmm6, %xmm6 - LONG $0xe4f4d1c5 // vpmuludq %xmm4, %xmm5, %xmm4 - LONG $0xe6d4d9c5 // vpaddq %xmm6, %xmm4, %xmm4 - LONG $0xd273d1c5; BYTE $0x20 // vpsrlq $32, %xmm2, %xmm5 - LONG $0xe9f4d1c5 // vpmuludq %xmm1, %xmm5, %xmm5 - LONG $0xd173c9c5; BYTE $0x20 // vpsrlq $32, %xmm1, %xmm6 - LONG $0xf6f4e9c5 // vpmuludq %xmm6, %xmm2, %xmm6 - LONG $0xedd4c9c5 // vpaddq %xmm5, %xmm6, %xmm5 - LONG $0xf573d1c5; BYTE $0x20 // vpsllq $32, %xmm5, %xmm5 - LONG $0xc9f4e9c5 // vpmuludq %xmm1, %xmm2, %xmm1 - LONG $0xcdd4f1c5 // vpaddq %xmm5, %xmm1, %xmm1 - LONG $0xd373e9c5; BYTE $0x20 // vpsrlq $32, %xmm3, %xmm2 - LONG $0xd1f4e9c5 // vpmuludq %xmm1, %xmm2, %xmm2 - LONG $0xd173d1c5; BYTE $0x20 // vpsrlq $32, %xmm1, %xmm5 - LONG $0xedf4e1c5 // vpmuludq %xmm5, %xmm3, %xmm5 - LONG $0xd2d4d1c5 // vpaddq %xmm2, %xmm5, %xmm2 - LONG $0xf273e9c5; BYTE $0x20 // vpsllq $32, %xmm2, %xmm2 - LONG $0xc9f4e1c5 // vpmuludq %xmm1, %xmm3, %xmm1 - LONG $0xcad4f1c5 // vpaddq %xmm2, %xmm1, %xmm1 - LONG $0x197de3c4; WORD $0x01da // vextractf128 $1, %ymm3, %xmm2 - LONG $0xd273e1c5; BYTE $0x20 // vpsrlq $32, %xmm2, %xmm3 - LONG $0xdcf4e1c5 // vpmuludq %xmm4, %xmm3, %xmm3 - LONG $0xd473d1c5; BYTE $0x20 // vpsrlq $32, %xmm4, %xmm5 - LONG $0xedf4e9c5 // vpmuludq %xmm5, %xmm2, %xmm5 - LONG $0xdbd4d1c5 // vpaddq %xmm3, %xmm5, %xmm3 - LONG $0xf373e1c5; BYTE $0x20 // vpsllq $32, %xmm3, %xmm3 - LONG $0xd4f4e9c5 // vpmuludq %xmm4, %xmm2, %xmm2 - LONG $0xd3d4e9c5 // vpaddq %xmm3, %xmm2, %xmm2 - LONG $0x197de3c4; WORD $0x01c3 // vextractf128 $1, %ymm0, %xmm3 - LONG $0xd373d9c5; BYTE $0x20 // vpsrlq $32, %xmm3, %xmm4 - LONG $0xe2f4d9c5 // vpmuludq %xmm2, %xmm4, %xmm4 - LONG $0xd273d1c5; BYTE $0x20 // vpsrlq $32, %xmm2, %xmm5 - LONG $0xedf4e1c5 // vpmuludq %xmm5, %xmm3, %xmm5 - LONG $0xe4d4d1c5 // vpaddq %xmm4, %xmm5, %xmm4 - LONG $0xf473d9c5; BYTE $0x20 // vpsllq $32, %xmm4, %xmm4 - LONG $0xd2f4e1c5 // vpmuludq %xmm2, %xmm3, %xmm2 - LONG $0xd4d4e9c5 // vpaddq %xmm4, %xmm2, %xmm2 - LONG $0xd073e1c5; BYTE $0x20 // vpsrlq $32, %xmm0, %xmm3 - LONG $0xd9f4e1c5 // vpmuludq %xmm1, %xmm3, %xmm3 - LONG $0xd173d9c5; BYTE $0x20 // vpsrlq $32, %xmm1, %xmm4 - LONG $0xe4f4f9c5 // vpmuludq %xmm4, %xmm0, %xmm4 - LONG $0xdbd4d9c5 // vpaddq %xmm3, %xmm4, %xmm3 - LONG $0xf373e1c5; BYTE $0x20 // vpsllq $32, %xmm3, %xmm3 - LONG $0xc1f4f9c5 // vpmuludq %xmm1, %xmm0, %xmm0 - LONG $0xc3d4f9c5 // vpaddq %xmm3, %xmm0, %xmm0 - LONG $0xd073f1c5; BYTE $0x20 // vpsrlq $32, %xmm0, %xmm1 - LONG $0xcaf4f1c5 // vpmuludq %xmm2, %xmm1, %xmm1 - LONG $0xd273e1c5; BYTE $0x20 // vpsrlq $32, %xmm2, %xmm3 - LONG $0xdbf4f9c5 // vpmuludq %xmm3, %xmm0, %xmm3 - LONG $0xc9d4e1c5 // vpaddq %xmm1, %xmm3, %xmm1 - LONG $0xf173f1c5; BYTE $0x20 // vpsllq $32, %xmm1, %xmm1 - LONG $0xc2f4f9c5 // vpmuludq %xmm2, %xmm0, %xmm0 - LONG $0xc1d4f9c5 // vpaddq %xmm1, %xmm0, %xmm0 - LONG $0xc870f9c5; BYTE $0xee // vpshufd $238, %xmm0, %xmm1 - LONG $0xd073e9c5; BYTE $0x20 // vpsrlq $32, %xmm0, %xmm2 - LONG $0xd1f4e9c5 // vpmuludq %xmm1, %xmm2, %xmm2 - LONG $0xd870f9c5; BYTE $0xff // vpshufd $255, %xmm0, %xmm3 - LONG $0xdbf4f9c5 // vpmuludq %xmm3, %xmm0, %xmm3 - LONG $0xd2d4e1c5 // vpaddq %xmm2, %xmm3, %xmm2 - LONG $0xf273e9c5; BYTE $0x20 // vpsllq $32, %xmm2, %xmm2 - LONG $0xc1f4f9c5 // vpmuludq %xmm1, %xmm0, %xmm0 - LONG $0xc2d4f9c5 // vpaddq %xmm2, %xmm0, %xmm0 - LONG $0x7ef9c1c4; BYTE $0xc4 // vmovq %xmm0, %r12 - WORD $0x3944; BYTE $0xc2 // cmpl %r8d, %edx - LONG $0x0024840f; WORD $0x0000 // je LBB13_60, $36(%rip) - WORD $0x0145; BYTE $0xc1 // addl %r8d, %r9d - -LBB13_58: - WORD $0xc289 // movl %eax, %edx - WORD $0x2944; BYTE $0xca // subl %r9d, %edx - QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 - -LBB13_59: +LBB9_44: WORD $0x014d; BYTE $0xe4 // addq %r12, %r12 LONG $0xa4248d4f // leaq (%r12,%r12,4), %r12 - WORD $0xcaff // decl %edx - LONG $0xfff1850f; WORD $0xffff // jne LBB13_59, $-15(%rip) + WORD $0xcfff // decl %edi + WORD $0xfe39 // cmpl %edi, %esi + LONG $0xffef850f; WORD $0xffff // jne LBB9_44, $-17(%rip) + WORD $0x2941; BYTE $0xf9 // subl %edi, %r9d + +LBB9_46: + WORD $0xfa83; BYTE $0x07 // cmpl $7, %edx + LONG $0x0023820f; WORD $0x0000 // jb LBB9_49, $35(%rip) + WORD $0xc289 // movl %eax, %edx + WORD $0x2944; BYTE $0xca // subl %r9d, %edx + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 + +LBB9_48: + LONG $0x00e4694d; WORD $0xf5e1; BYTE $0x05 // imulq $100000000, %r12, %r12 + WORD $0xc283; BYTE $0xf8 // addl $-8, %edx + LONG $0xfff0850f; WORD $0xffff // jne LBB9_48, $-16(%rip) -LBB13_60: +LBB9_49: WORD $0xc085 // testl %eax, %eax - LONG $0x004b880f; WORD $0x0000 // js LBB13_67, $75(%rip) - LONG $0x10578b41 // movl $16(%r15), %edx - WORD $0xc239 // cmpl %eax, %edx - LONG $0x003f8e0f; WORD $0x0000 // jle LBB13_67, $63(%rip) - WORD $0x8b49; BYTE $0x37 // movq (%r15), %rsi - LONG $0x060cb60f // movzbl (%rsi,%rax), %ecx - WORD $0xf980; BYTE $0x35 // cmpb $53, %cl - LONG $0x00b2850f; WORD $0x0000 // jne LBB13_69, $178(%rip) + LONG $0x0049880f; WORD $0x0000 // js LBB9_57, $73(%rip) + LONG $0x10778b41 // movl $16(%r15), %esi + WORD $0xc639 // cmpl %eax, %esi + LONG $0x003d8e0f; WORD $0x0000 // jle LBB9_57, $61(%rip) + WORD $0x8b49; BYTE $0x17 // movq (%r15), %rdx + WORD $0x0c8a; BYTE $0x02 // movb (%rdx,%rax), %cl WORD $0x788d; BYTE $0x01 // leal $1(%rax), %edi - WORD $0xd739 // cmpl %edx, %edi - LONG $0x00a7850f; WORD $0x0000 // jne LBB13_69, $167(%rip) - WORD $0x01b2 // movb $1, %dl + WORD $0xf739 // cmpl %esi, %edi + LONG $0x00be850f; WORD $0x0000 // jne LBB9_58, $190(%rip) + WORD $0xf980; BYTE $0x35 // cmpb $53, %cl + LONG $0x00b5850f; WORD $0x0000 // jne LBB9_58, $181(%rip) LONG $0x1c7f8341; BYTE $0x00 // cmpl $0, $28(%r15) - LONG $0x0019850f; WORD $0x0000 // jne LBB13_70, $25(%rip) - WORD $0x8548; BYTE $0xc0 // testq %rax, %rax - LONG $0x000e840f; WORD $0x0000 // je LBB13_67, $14(%rip) + WORD $0x950f; BYTE $0xc1 // setne %cl + LONG $0x0017850f; WORD $0x0000 // jne LBB9_59, $23(%rip) + WORD $0xc085 // testl %eax, %eax + LONG $0x000f8e0f; WORD $0x0000 // jle LBB9_59, $15(%rip) WORD $0xc8ff // decl %eax - LONG $0x0614b60f // movzbl (%rsi,%rax), %edx - WORD $0xe280; BYTE $0x01 // andb $1, %dl - LONG $0x000002e9; BYTE $0x00 // jmp LBB13_70, $2(%rip) + WORD $0x0c8a; BYTE $0x02 // movb (%rdx,%rax), %cl + WORD $0xe180; BYTE $0x01 // andb $1, %cl + LONG $0x000002e9; BYTE $0x00 // jmp LBB9_59, $2(%rip) -LBB13_67: - WORD $0xd231 // xorl %edx, %edx +LBB9_57: + WORD $0xc931 // xorl %ecx, %ecx -LBB13_70: - WORD $0xb60f; BYTE $0xc2 // movzbl %dl, %eax +LBB9_59: + WORD $0xb60f; BYTE $0xc1 // movzbl %cl, %eax WORD $0x0149; BYTE $0xc4 // addq %rax, %r12 QUAD $0x000000000000b848; WORD $0x0020 // movabsq $9007199254740992, %rax WORD $0x3949; BYTE $0xc4 // cmpq %rax, %r12 - LONG $0x0013850f; WORD $0x0000 // jne LBB13_73, $19(%rip) + LONG $0x0025850f; WORD $0x0000 // jne LBB9_63, $37(%rip) LONG $0xfefe8141; WORD $0x0003; BYTE $0x00 // cmpl $1022, %r14d - LONG $0xf90d8f0f; WORD $0xffff // jg LBB13_2, $-1779(%rip) - WORD $0xff41; BYTE $0xc6 // incl %r14d - WORD $0x894d; BYTE $0xec // movq %r13, %r12 + LONG $0x00128e0f; WORD $0x0000 // jle LBB9_62, $18(%rip) -LBB13_73: +LBB9_61: + WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d + QUAD $0x000000000000be49; WORD $0x7ff0 // movabsq $9218868437227405312, %r14 + LONG $0x000025e9; BYTE $0x00 // jmp LBB9_64, $37(%rip) + +LBB9_62: + WORD $0xff41; BYTE $0xc6 // incl %r14d + WORD $0x894d; BYTE $0xec // movq %r13, %r12 + +LBB9_63: WORD $0x894c; BYTE $0xe0 // movq %r12, %rax WORD $0x214c; BYTE $0xe8 // andq %r13, %rax LONG $0xffc68141; WORD $0x0003; BYTE $0x00 // addl $1023, %r14d @@ -3866,7 +3302,7 @@ LBB13_73: WORD $0x8548; BYTE $0xc0 // testq %rax, %rax LONG $0xf0440f4c // cmoveq %rax, %r14 -LBB13_74: +LBB9_64: WORD $0xff49; BYTE $0xcd // decq %r13 WORD $0x214d; BYTE $0xe5 // andq %r12, %r13 WORD $0x094d; BYTE $0xf5 // orq %r14, %r13 @@ -3883,945 +3319,743 @@ LBB13_74: WORD $0x5e41 // popq %r14 WORD $0x5f41 // popq %r15 BYTE $0x5d // popq %rbp - WORD $0xf8c5; BYTE $0x77 // vzeroupper BYTE $0xc3 // retq -LBB13_69: - WORD $0xf980; BYTE $0x35 // cmpb $53, %cl - WORD $0x9d0f; BYTE $0xc2 // setge %dl - LONG $0xffff74e9; BYTE $0xff // jmp LBB13_70, $-140(%rip) +LBB9_58: + WORD $0xf980; BYTE $0x34 // cmpb $52, %cl + WORD $0x9f0f; BYTE $0xc1 // setg %cl + LONG $0xffff65e9; BYTE $0xff // jmp LBB9_59, $-155(%rip) + WORD $0x9090 // .p2align 4, 0x90 - // .p2align 4, 0x90 _atof_native: - BYTE $0x55 // pushq %rbp - WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp - WORD $0x5741 // pushq %r15 - WORD $0x5641 // pushq %r14 - WORD $0x5541 // pushq %r13 - WORD $0x5441 // pushq %r12 - BYTE $0x53 // pushq %rbx - LONG $0x28ec8348 // subq $40, %rsp - QUAD $0x00000000d045c748 // movq $0, $-48(%rbp) - LONG $0xb0558948 // movq %rdx, $-80(%rbp) - LONG $0xb84d8948 // movq %rcx, $-72(%rbp) - WORD $0x8548; BYTE $0xc9 // testq %rcx, %rcx - LONG $0x0197840f; WORD $0x0000 // je LBB14_18, $407(%rip) - LONG $0x10f98348 // cmpq $16, %rcx - LONG $0x0008830f; WORD $0x0000 // jae LBB14_3, $8(%rip) - WORD $0x3145; BYTE $0xd2 // xorl %r10d, %r10d - LONG $0x000174e9; BYTE $0x00 // jmp LBB14_17, $372(%rip) - -LBB14_3: - LONG $0x80f98148; WORD $0x0000; BYTE $0x00 // cmpq $128, %rcx - LONG $0x0008830f; WORD $0x0000 // jae LBB14_5, $8(%rip) - WORD $0x3145; BYTE $0xd2 // xorl %r10d, %r10d - LONG $0x000129e9; BYTE $0x00 // jmp LBB14_14, $297(%rip) - -LBB14_5: - WORD $0x8949; BYTE $0xca // movq %rcx, %r10 - LONG $0x80e28349 // andq $-128, %r10 - LONG $0x80428d49 // leaq $-128(%r10), %rax - WORD $0x8949; BYTE $0xc1 // movq %rax, %r9 - LONG $0x07e9c149 // shrq $7, %r9 - WORD $0xff49; BYTE $0xc1 // incq %r9 - WORD $0x8945; BYTE $0xc8 // movl %r9d, %r8d - LONG $0x03e08341 // andl $3, %r8d - LONG $0x01803d48; WORD $0x0000 // cmpq $384, %rax - LONG $0x0007830f; WORD $0x0000 // jae LBB14_7, $7(%rip) - WORD $0xdb31 // xorl %ebx, %ebx - LONG $0x0000a4e9; BYTE $0x00 // jmp LBB14_9, $164(%rip) + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + LONG $0x30ec8348 // subq $48, %rsp + QUAD $0x00000000d845c748 // movq $0, $-40(%rbp) + LONG $0xe0558948 // movq %rdx, $-32(%rbp) + LONG $0xe84d8948 // movq %rcx, $-24(%rbp) + WORD $0x8548; BYTE $0xc9 // testq %rcx, %rcx + LONG $0x0044840f; WORD $0x0000 // je LBB10_5, $68(%rip) + WORD $0x02c6; BYTE $0x00 // movb $0, (%rdx) + LONG $0x01f98348 // cmpq $1, %rcx + LONG $0x0037840f; WORD $0x0000 // je LBB10_5, $55(%rip) + LONG $0x000142c6 // movb $0, $1(%rdx) + LONG $0xe87d8348; BYTE $0x03 // cmpq $3, $-24(%rbp) + LONG $0x0028820f; WORD $0x0000 // jb LBB10_5, $40(%rip) + LONG $0x000002b8; BYTE $0x00 // movl $2, %eax + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 -LBB14_7: - LONG $0xfce18349 // andq $-4, %r9 - WORD $0xdb31 // xorl %ebx, %ebx - LONG $0xc057f8c5 // vxorps %xmm0, %xmm0, %xmm0 - LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 +LBB10_4: + LONG $0xe04d8b48 // movq $-32(%rbp), %rcx + LONG $0x000104c6 // movb $0, (%rcx,%rax) + WORD $0xff48; BYTE $0xc0 // incq %rax + LONG $0xe8453948 // cmpq %rax, $-24(%rbp) + LONG $0xffeb870f; WORD $0xffff // ja LBB10_4, $-21(%rip) -LBB14_8: - LONG $0x0411fcc5; BYTE $0x1a // vmovups %ymm0, (%rdx,%rbx) - LONG $0x4411fcc5; WORD $0x201a // vmovups %ymm0, $32(%rdx,%rbx) - LONG $0x4411fcc5; WORD $0x401a // vmovups %ymm0, $64(%rdx,%rbx) - LONG $0x4411fcc5; WORD $0x601a // vmovups %ymm0, $96(%rdx,%rbx) - QUAD $0x0000801a8411fcc5; BYTE $0x00 // vmovups %ymm0, $128(%rdx,%rbx) - QUAD $0x0000a01a8411fcc5; BYTE $0x00 // vmovups %ymm0, $160(%rdx,%rbx) - QUAD $0x0000c01a8411fcc5; BYTE $0x00 // vmovups %ymm0, $192(%rdx,%rbx) - QUAD $0x0000e01a8411fcc5; BYTE $0x00 // vmovups %ymm0, $224(%rdx,%rbx) - QUAD $0x0001001a8411fcc5; BYTE $0x00 // vmovups %ymm0, $256(%rdx,%rbx) - QUAD $0x0001201a8411fcc5; BYTE $0x00 // vmovups %ymm0, $288(%rdx,%rbx) - QUAD $0x0001401a8411fcc5; BYTE $0x00 // vmovups %ymm0, $320(%rdx,%rbx) - QUAD $0x0001601a8411fcc5; BYTE $0x00 // vmovups %ymm0, $352(%rdx,%rbx) - QUAD $0x0001801a8411fcc5; BYTE $0x00 // vmovups %ymm0, $384(%rdx,%rbx) - QUAD $0x0001a01a8411fcc5; BYTE $0x00 // vmovups %ymm0, $416(%rdx,%rbx) - QUAD $0x0001c01a8411fcc5; BYTE $0x00 // vmovups %ymm0, $448(%rdx,%rbx) - QUAD $0x0001e01a8411fcc5; BYTE $0x00 // vmovups %ymm0, $480(%rdx,%rbx) - LONG $0x00c38148; WORD $0x0002; BYTE $0x00 // addq $512, %rbx - LONG $0xfcc18349 // addq $-4, %r9 - LONG $0xff6c850f; WORD $0xffff // jne LBB14_8, $-148(%rip) +LBB10_5: + LONG $0xc057f8c5 // vxorps %xmm0, %xmm0, %xmm0 + LONG $0x4511f8c5; BYTE $0xf0 // vmovups %xmm0, $-16(%rbp) + WORD $0x3f80; BYTE $0x2d // cmpb $45, (%rdi) + LONG $0x0021850f; WORD $0x0000 // jne LBB10_8, $33(%rip) + LONG $0x01f845c7; WORD $0x0000; BYTE $0x00 // movl $1, $-8(%rbp) + LONG $0x000001b8; BYTE $0x00 // movl $1, %eax + WORD $0x3948; BYTE $0xf0 // cmpq %rsi, %rax + LONG $0x00178c0f; WORD $0x0000 // jl LBB10_9, $23(%rip) -LBB14_9: - WORD $0x854d; BYTE $0xc0 // testq %r8, %r8 - LONG $0x003b840f; WORD $0x0000 // je LBB14_12, $59(%rip) - LONG $0x130c8d4c // leaq (%rbx,%rdx), %r9 - LONG $0x60c18349 // addq $96, %r9 - LONG $0x07e0c149 // shlq $7, %r8 - WORD $0xdb31 // xorl %ebx, %ebx - LONG $0xc057f8c5 // vxorps %xmm0, %xmm0, %xmm0 - BYTE $0x90 // .p2align 4, 0x90 +LBB10_7: + LONG $0x00f445c7; WORD $0x0000; BYTE $0x00 // movl $0, $-12(%rbp) + LONG $0x0001a1e9; BYTE $0x00 // jmp LBB10_39, $417(%rip) -LBB14_11: - LONG $0x117cc1c4; WORD $0x1944; BYTE $0xa0 // vmovups %ymm0, $-96(%r9,%rbx) - LONG $0x117cc1c4; WORD $0x1944; BYTE $0xc0 // vmovups %ymm0, $-64(%r9,%rbx) - LONG $0x117cc1c4; WORD $0x1944; BYTE $0xe0 // vmovups %ymm0, $-32(%r9,%rbx) - LONG $0x117cc1c4; WORD $0x1904 // vmovups %ymm0, (%r9,%rbx) - LONG $0x80eb8348 // subq $-128, %rbx - WORD $0x3949; BYTE $0xd8 // cmpq %rbx, %r8 - LONG $0xffd8850f; WORD $0xffff // jne LBB14_11, $-40(%rip) +LBB10_8: + WORD $0xc031 // xorl %eax, %eax + WORD $0x3948; BYTE $0xf0 // cmpq %rsi, %rax + LONG $0xffe98d0f; WORD $0xffff // jge LBB10_7, $-23(%rip) -LBB14_12: - WORD $0x3949; BYTE $0xca // cmpq %rcx, %r10 - LONG $0x0050840f; WORD $0x0000 // je LBB14_18, $80(%rip) - WORD $0xc1f6; BYTE $0x70 // testb $112, %cl - LONG $0x0036840f; WORD $0x0000 // je LBB14_17, $54(%rip) +LBB10_9: + WORD $0xb341; BYTE $0x01 // movb $1, %r11b + WORD $0x3145; BYTE $0xc9 // xorl %r9d, %r9d + WORD $0x3145; BYTE $0xd2 // xorl %r10d, %r10d + WORD $0x3145; BYTE $0xc0 // xorl %r8d, %r8d + LONG $0x00001fe9; BYTE $0x00 // jmp LBB10_13, $31(%rip) -LBB14_14: - WORD $0x894c; BYTE $0xd0 // movq %r10, %rax - WORD $0x8949; BYTE $0xca // movq %rcx, %r10 - LONG $0xf0e28349 // andq $-16, %r10 - LONG $0xc057f8c5 // vxorps %xmm0, %xmm0, %xmm0 - QUAD $0x9090909090909090 // .p2align 4, 0x90 +LBB10_21: + LONG $0x01fc45c7; WORD $0x0000; BYTE $0x00 // movl $1, $-4(%rbp) + LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 -LBB14_15: - LONG $0x0411f8c5; BYTE $0x02 // vmovups %xmm0, (%rdx,%rax) - LONG $0x10c08348 // addq $16, %rax - WORD $0x3949; BYTE $0xc2 // cmpq %rax, %r10 - LONG $0xffee850f; WORD $0xffff // jne LBB14_15, $-18(%rip) - WORD $0x3949; BYTE $0xca // cmpq %rcx, %r10 - LONG $0x0016840f; WORD $0x0000 // je LBB14_18, $22(%rip) - LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 +LBB10_12: + WORD $0xff48; BYTE $0xc0 // incq %rax + WORD $0x3948; BYTE $0xf0 // cmpq %rsi, %rax + LONG $0xc39c0f41 // setl %r11b + WORD $0x3948; BYTE $0xc6 // cmpq %rax, %rsi + LONG $0x0090840f; WORD $0x0000 // je LBB10_23, $144(%rip) + +LBB10_13: + LONG $0x070cb60f // movzbl (%rdi,%rax), %ecx + WORD $0x518d; BYTE $0xd0 // leal $-48(%rcx), %edx + WORD $0xfa80; BYTE $0x09 // cmpb $9, %dl + LONG $0x002d870f; WORD $0x0000 // ja LBB10_18, $45(%rip) + WORD $0xf980; BYTE $0x30 // cmpb $48, %cl + LONG $0x0044850f; WORD $0x0000 // jne LBB10_20, $68(%rip) + WORD $0x8545; BYTE $0xd2 // testl %r10d, %r10d + LONG $0x0063840f; WORD $0x0000 // je LBB10_22, $99(%rip) + WORD $0x634d; BYTE $0xd9 // movslq %r9d, %r11 + LONG $0xe85d394c // cmpq %r11, $-24(%rbp) + LONG $0x003b870f; WORD $0x0000 // ja LBB10_10, $59(%rip) + LONG $0x000049e9; BYTE $0x00 // jmp LBB10_11, $73(%rip) + QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90 -LBB14_17: - LONG $0x1204c642; BYTE $0x00 // movb $0, (%rdx,%r10) - WORD $0xff49; BYTE $0xc2 // incq %r10 - WORD $0x394c; BYTE $0xd1 // cmpq %r10, %rcx - LONG $0xffef850f; WORD $0xffff // jne LBB14_17, $-17(%rip) +LBB10_18: + WORD $0xf980; BYTE $0x2e // cmpb $46, %cl + LONG $0x009b850f; WORD $0x0000 // jne LBB10_30, $155(%rip) + LONG $0xf4558944 // movl %r10d, $-12(%rbp) + LONG $0x0001b841; WORD $0x0000 // movl $1, %r8d + LONG $0xffff98e9; BYTE $0xff // jmp LBB10_12, $-104(%rip) + QUAD $0x9090909090909090 // .p2align 4, 0x90 -LBB14_18: - LONG $0x00c045c7; WORD $0x0000; BYTE $0x00 // movl $0, $-64(%rbp) - QUAD $0x00000000c845c748 // movq $0, $-56(%rbp) - WORD $0x3145; BYTE $0xc0 // xorl %r8d, %r8d - WORD $0x3f80; BYTE $0x2d // cmpb $45, (%rdi) - LONG $0x001b850f; WORD $0x0000 // jne LBB14_19, $27(%rip) - LONG $0x01c845c7; WORD $0x0000; BYTE $0x00 // movl $1, $-56(%rbp) - LONG $0x0001bd41; WORD $0x0000 // movl $1, %r13d - WORD $0x3949; BYTE $0xf5 // cmpq %rsi, %r13 - LONG $0x00118c0f; WORD $0x0000 // jl LBB14_22, $17(%rip) - LONG $0x0001b5e9; BYTE $0x00 // jmp LBB14_54, $437(%rip) +LBB10_20: + WORD $0x634d; BYTE $0xda // movslq %r10d, %r11 + LONG $0xe85d394c // cmpq %r11, $-24(%rbp) + LONG $0xff77860f; WORD $0xffff // jbe LBB10_21, $-137(%rip) -LBB14_19: - WORD $0x3145; BYTE $0xed // xorl %r13d, %r13d - WORD $0x3949; BYTE $0xf5 // cmpq %rsi, %r13 - LONG $0x01a98d0f; WORD $0x0000 // jge LBB14_54, $425(%rip) +LBB10_10: + LONG $0xe0558b48 // movq $-32(%rbp), %rdx + LONG $0x1a0c8842 // movb %cl, (%rdx,%r11) + LONG $0xf04d8b44 // movl $-16(%rbp), %r9d + WORD $0xff41; BYTE $0xc1 // incl %r9d + LONG $0xf04d8944 // movl %r9d, $-16(%rbp) -LBB14_22: - WORD $0xb741; BYTE $0x01 // movb $1, %r15b - WORD $0x3145; BYTE $0xc0 // xorl %r8d, %r8d - WORD $0x3145; BYTE $0xc9 // xorl %r9d, %r9d - WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d - WORD $0x3145; BYTE $0xdb // xorl %r11d, %r11d - WORD $0xdb31 // xorl %ebx, %ebx - LONG $0x000027e9; BYTE $0x00 // jmp LBB14_23, $39(%rip) - LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 +LBB10_11: + WORD $0x8945; BYTE $0xca // movl %r9d, %r10d + LONG $0xffff68e9; BYTE $0xff // jmp LBB10_12, $-152(%rip) -LBB14_33: - LONG $0x000001bb; BYTE $0x00 // movl $1, %ebx - WORD $0x8945; BYTE $0xdc // movl %r11d, %r12d - WORD $0x2e3c // cmpb $46, %al - LONG $0x0095850f; WORD $0x0000 // jne LBB14_36, $149(%rip) +LBB10_22: + WORD $0x4dff; BYTE $0xf4 // decl $-12(%rbp) + WORD $0x3145; BYTE $0xd2 // xorl %r10d, %r10d + LONG $0xffff5de9; BYTE $0xff // jmp LBB10_12, $-163(%rip) -LBB14_34: - WORD $0xff49; BYTE $0xc5 // incq %r13 - WORD $0x3949; BYTE $0xf5 // cmpq %rsi, %r13 - LONG $0xc79c0f41 // setl %r15b - LONG $0x007c840f; WORD $0x0000 // je LBB14_35, $124(%rip) +LBB10_23: + WORD $0xf189 // movl %esi, %ecx + WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax + WORD $0x8545; BYTE $0xc0 // testl %r8d, %r8d + LONG $0x0004850f; WORD $0x0000 // jne LBB10_25, $4(%rip) + +LBB10_24: + LONG $0xf44d8944 // movl %r9d, $-12(%rbp) + +LBB10_25: + LONG $0x01c3f641 // testb $1, %r11b + LONG $0x00ba840f; WORD $0x0000 // je LBB10_39, $186(%rip) + WORD $0x0c8a; BYTE $0x0f // movb (%rdi,%rcx), %cl + WORD $0xc980; BYTE $0x20 // orb $32, %cl + WORD $0xf980; BYTE $0x65 // cmpb $101, %cl + LONG $0x00ab850f; WORD $0x0000 // jne LBB10_39, $171(%rip) + WORD $0xc289 // movl %eax, %edx + LONG $0x01174c8a // movb $1(%rdi,%rdx), %cl + WORD $0xf980; BYTE $0x2d // cmpb $45, %cl + LONG $0x0028840f; WORD $0x0000 // je LBB10_31, $40(%rip) + LONG $0x0001b841; WORD $0x0000 // movl $1, %r8d + WORD $0xf980; BYTE $0x2b // cmpb $43, %cl + LONG $0x0038850f; WORD $0x0000 // jne LBB10_33, $56(%rip) + WORD $0xc083; BYTE $0x02 // addl $2, %eax + LONG $0x00001ae9; BYTE $0x00 // jmp LBB10_32, $26(%rip) + +LBB10_30: + WORD $0x8948; BYTE $0xc1 // movq %rax, %rcx + WORD $0x8545; BYTE $0xc0 // testl %r8d, %r8d + LONG $0xffb5850f; WORD $0xffff // jne LBB10_25, $-75(%rip) + LONG $0xfffface9; BYTE $0xff // jmp LBB10_24, $-84(%rip) -LBB14_23: - WORD $0x8941; BYTE $0xda // movl %ebx, %r10d - WORD $0x8945; BYTE $0xe6 // movl %r12d, %r14d - LONG $0x04b60f42; BYTE $0x2f // movzbl (%rdi,%r13), %eax - WORD $0x588d; BYTE $0xd0 // leal $-48(%rax), %ebx - WORD $0xfb80; BYTE $0x09 // cmpb $9, %bl - LONG $0xffc9870f; WORD $0xffff // ja LBB14_33, $-55(%rip) - WORD $0x303c // cmpb $48, %al - LONG $0x0021850f; WORD $0x0000 // jne LBB14_29, $33(%rip) - WORD $0x8545; BYTE $0xdb // testl %r11d, %r11d - LONG $0x0043840f; WORD $0x0000 // je LBB14_26, $67(%rip) - WORD $0x6349; BYTE $0xd8 // movslq %r8d, %rbx - WORD $0x3948; BYTE $0xcb // cmpq %rcx, %rbx - LONG $0x0018820f; WORD $0x0000 // jb LBB14_32, $24(%rip) - LONG $0x000019e9; BYTE $0x00 // jmp LBB14_28, $25(%rip) - LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 +LBB10_31: + WORD $0xc083; BYTE $0x02 // addl $2, %eax + LONG $0xffffb841; WORD $0xffff // movl $-1, %r8d -LBB14_29: - WORD $0x6349; BYTE $0xdb // movslq %r11d, %rbx - WORD $0x3948; BYTE $0xcb // cmpq %rcx, %rbx - LONG $0x0014830f; WORD $0x0000 // jae LBB14_30, $20(%rip) +LBB10_32: + WORD $0xc289 // movl %eax, %edx + WORD $0x6348; BYTE $0xd2 // movslq %edx, %rdx + WORD $0x3145; BYTE $0xc9 // xorl %r9d, %r9d + WORD $0x3948; BYTE $0xf2 // cmpq %rsi, %rdx + LONG $0x00178c0f; WORD $0x0000 // jl LBB10_34, $23(%rip) + LONG $0x00004de9; BYTE $0x00 // jmp LBB10_38, $77(%rip) -LBB14_32: - WORD $0x0488; BYTE $0x1a // movb %al, (%rdx,%rbx) - WORD $0xff41; BYTE $0xc0 // incl %r8d +LBB10_33: + WORD $0xff48; BYTE $0xc2 // incq %rdx + WORD $0x6348; BYTE $0xd2 // movslq %edx, %rdx + WORD $0x3145; BYTE $0xc9 // xorl %r9d, %r9d + WORD $0x3948; BYTE $0xf2 // cmpq %rsi, %rdx + LONG $0x003b8d0f; WORD $0x0000 // jge LBB10_38, $59(%rip) -LBB14_28: - WORD $0x8945; BYTE $0xf4 // movl %r14d, %r12d - WORD $0x8945; BYTE $0xc3 // movl %r8d, %r11d - WORD $0x8944; BYTE $0xd3 // movl %r10d, %ebx - LONG $0xffff90e9; BYTE $0xff // jmp LBB14_34, $-112(%rip) +LBB10_34: + WORD $0x3145; BYTE $0xc9 // xorl %r9d, %r9d + LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 -LBB14_30: - LONG $0x0001b941; WORD $0x0000 // movl $1, %r9d - LONG $0x000006e9; BYTE $0x00 // jmp LBB14_31, $6(%rip) - -LBB14_26: - WORD $0xff41; BYTE $0xce // decl %r14d - WORD $0x3145; BYTE $0xdb // xorl %r11d, %r11d - -LBB14_31: - WORD $0x8945; BYTE $0xf4 // movl %r14d, %r12d - WORD $0x8944; BYTE $0xd3 // movl %r10d, %ebx - LONG $0xffff74e9; BYTE $0xff // jmp LBB14_34, $-140(%rip) - -LBB14_35: - WORD $0x8945; BYTE $0xe6 // movl %r12d, %r14d - WORD $0x8949; BYTE $0xf5 // movq %rsi, %r13 - WORD $0x8941; BYTE $0xda // movl %ebx, %r10d - -LBB14_36: - LONG $0xc4758944 // movl %r14d, $-60(%rbp) - LONG $0xcc4d8944 // movl %r9d, $-52(%rbp) - LONG $0xc0458944 // movl %r8d, $-64(%rbp) - WORD $0x8545; BYTE $0xd2 // testl %r10d, %r10d - LONG $0x0012840f; WORD $0x0000 // je LBB14_37, $18(%rip) - WORD $0x8945; BYTE $0xf0 // movl %r14d, %r8d - LONG $0x01c7f641 // testb $1, %r15b - LONG $0x0013850f; WORD $0x0000 // jne LBB14_40, $19(%rip) - LONG $0x0000c4e9; BYTE $0x00 // jmp LBB14_55, $196(%rip) +LBB10_35: + LONG $0x0ff98141; WORD $0x0027; BYTE $0x00 // cmpl $9999, %r9d + LONG $0x00248f0f; WORD $0x0000 // jg LBB10_38, $36(%rip) + LONG $0x170cb60f // movzbl (%rdi,%rdx), %ecx + WORD $0x418d; BYTE $0xd0 // leal $-48(%rcx), %eax + WORD $0x093c // cmpb $9, %al + LONG $0x0015870f; WORD $0x0000 // ja LBB10_38, $21(%rip) + LONG $0x89048d43 // leal (%r9,%r9,4), %eax + LONG $0x414c8d44; BYTE $0xd0 // leal $-48(%rcx,%rax,2), %r9d + WORD $0xff48; BYTE $0xc2 // incq %rdx + WORD $0x3948; BYTE $0xd6 // cmpq %rdx, %rsi + LONG $0xffcf850f; WORD $0xffff // jne LBB10_35, $-49(%rip) + +LBB10_38: + LONG $0xc8af0f45 // imull %r8d, %r9d + LONG $0xf44d0144 // addl %r9d, $-12(%rbp) + +LBB10_39: + LONG $0xe07d8d48 // leaq $-32(%rbp), %rdi + LONG $0xd8758d48 // leaq $-40(%rbp), %rsi + LONG $0xfff9eae8; BYTE $0xff // callq _decimal_to_f64, $-1558(%rip) + LONG $0x4510fbc5; BYTE $0xd8 // vmovsd $-40(%rbp), %xmm0 + LONG $0x30c48348 // addq $48, %rsp + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 -LBB14_37: - LONG $0xc4458944 // movl %r8d, $-60(%rbp) - LONG $0x01c7f641 // testb $1, %r15b - LONG $0x00b6840f; WORD $0x0000 // je LBB14_55, $182(%rip) - -LBB14_40: - WORD $0x8944; BYTE $0xe8 // movl %r13d, %eax - LONG $0x070cb60f // movzbl (%rdi,%rax), %ecx - WORD $0xc983; BYTE $0x20 // orl $32, %ecx - WORD $0xf983; BYTE $0x65 // cmpl $101, %ecx - LONG $0x00a3850f; WORD $0x0000 // jne LBB14_55, $163(%rip) - LONG $0x0754b60f; BYTE $0x01 // movzbl $1(%rdi,%rax), %edx - WORD $0xfa83; BYTE $0x2d // cmpl $45, %edx - LONG $0x0017840f; WORD $0x0000 // je LBB14_45, $23(%rip) - LONG $0x000001b9; BYTE $0x00 // movl $1, %ecx - WORD $0xfa83; BYTE $0x2b // cmpl $43, %edx - LONG $0x0028850f; WORD $0x0000 // jne LBB14_43, $40(%rip) - LONG $0x02c58341 // addl $2, %r13d - LONG $0x000009e9; BYTE $0x00 // jmp LBB14_46, $9(%rip) +_value: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5741 // pushq %r15 + WORD $0x5641 // pushq %r14 + WORD $0x5541 // pushq %r13 + WORD $0x5441 // pushq %r12 + BYTE $0x53 // pushq %rbx + LONG $0x28ec8348 // subq $40, %rsp + WORD $0x8949; BYTE $0xce // movq %rcx, %r14 + WORD $0x8949; BYTE $0xd4 // movq %rdx, %r12 + WORD $0x8949; BYTE $0xf7 // movq %rsi, %r15 + WORD $0x8949; BYTE $0xfd // movq %rdi, %r13 + LONG $0xd0558948 // movq %rdx, $-48(%rbp) + LONG $0xb07d8948 // movq %rdi, $-80(%rbp) + LONG $0xb8758948 // movq %rsi, $-72(%rbp) + WORD $0x8948; BYTE $0xd0 // movq %rdx, %rax + WORD $0x2948; BYTE $0xf0 // subq %rsi, %rax + LONG $0x002b830f; WORD $0x0000 // jae LBB11_5, $43(%rip) + LONG $0x254c8a43; BYTE $0x00 // movb (%r13,%r12), %cl + WORD $0xf980; BYTE $0x0d // cmpb $13, %cl + LONG $0x001d840f; WORD $0x0000 // je LBB11_5, $29(%rip) + WORD $0xf980; BYTE $0x20 // cmpb $32, %cl + LONG $0x0014840f; WORD $0x0000 // je LBB11_5, $20(%rip) + WORD $0x518d; BYTE $0xf7 // leal $-9(%rcx), %edx + WORD $0xfa80; BYTE $0x01 // cmpb $1, %dl + LONG $0x0008860f; WORD $0x0000 // jbe LBB11_5, $8(%rip) + WORD $0x894c; BYTE $0xe3 // movq %r12, %rbx + LONG $0x000132e9; BYTE $0x00 // jmp LBB11_28, $306(%rip) + +LBB11_5: + LONG $0x245c8d49; BYTE $0x01 // leaq $1(%r12), %rbx + WORD $0x394c; BYTE $0xfb // cmpq %r15, %rbx + LONG $0x0023830f; WORD $0x0000 // jae LBB11_9, $35(%rip) + LONG $0x1d4c8a41; BYTE $0x00 // movb (%r13,%rbx), %cl + WORD $0xf980; BYTE $0x0d // cmpb $13, %cl + LONG $0x0015840f; WORD $0x0000 // je LBB11_9, $21(%rip) + WORD $0xf980; BYTE $0x20 // cmpb $32, %cl + LONG $0x000c840f; WORD $0x0000 // je LBB11_9, $12(%rip) + WORD $0x518d; BYTE $0xf7 // leal $-9(%rcx), %edx + WORD $0xfa80; BYTE $0x01 // cmpb $1, %dl + LONG $0x0101870f; WORD $0x0000 // ja LBB11_28, $257(%rip) + +LBB11_9: + LONG $0x245c8d49; BYTE $0x02 // leaq $2(%r12), %rbx + WORD $0x394c; BYTE $0xfb // cmpq %r15, %rbx + LONG $0x0023830f; WORD $0x0000 // jae LBB11_13, $35(%rip) + LONG $0x1d4c8a41; BYTE $0x00 // movb (%r13,%rbx), %cl + WORD $0xf980; BYTE $0x0d // cmpb $13, %cl + LONG $0x0015840f; WORD $0x0000 // je LBB11_13, $21(%rip) + WORD $0xf980; BYTE $0x20 // cmpb $32, %cl + LONG $0x000c840f; WORD $0x0000 // je LBB11_13, $12(%rip) + WORD $0x518d; BYTE $0xf7 // leal $-9(%rcx), %edx + WORD $0xfa80; BYTE $0x01 // cmpb $1, %dl + LONG $0x00d0870f; WORD $0x0000 // ja LBB11_28, $208(%rip) -LBB14_45: - LONG $0x02c58341 // addl $2, %r13d - LONG $0xffffffb9; BYTE $0xff // movl $-1, %ecx +LBB11_13: + LONG $0x245c8d49; BYTE $0x03 // leaq $3(%r12), %rbx + WORD $0x394c; BYTE $0xfb // cmpq %r15, %rbx + LONG $0x0023830f; WORD $0x0000 // jae LBB11_17, $35(%rip) + LONG $0x1d4c8a41; BYTE $0x00 // movb (%r13,%rbx), %cl + WORD $0xf980; BYTE $0x0d // cmpb $13, %cl + LONG $0x0015840f; WORD $0x0000 // je LBB11_17, $21(%rip) + WORD $0xf980; BYTE $0x20 // cmpb $32, %cl + LONG $0x000c840f; WORD $0x0000 // je LBB11_17, $12(%rip) + WORD $0x518d; BYTE $0xf7 // leal $-9(%rcx), %edx + WORD $0xfa80; BYTE $0x01 // cmpb $1, %dl + LONG $0x009f870f; WORD $0x0000 // ja LBB11_28, $159(%rip) -LBB14_46: - WORD $0x8944; BYTE $0xe8 // movl %r13d, %eax - WORD $0x6348; BYTE $0xd0 // movslq %eax, %rdx - WORD $0xc031 // xorl %eax, %eax - WORD $0x3948; BYTE $0xf2 // cmpq %rsi, %rdx - LONG $0x00168c0f; WORD $0x0000 // jl LBB14_48, $22(%rip) - LONG $0x000055e9; BYTE $0x00 // jmp LBB14_53, $85(%rip) +LBB11_17: + LONG $0x244c8d49; BYTE $0x04 // leaq $4(%r12), %rcx + WORD $0x394c; BYTE $0xf9 // cmpq %r15, %rcx + LONG $0x0057830f; WORD $0x0000 // jae LBB11_23, $87(%rip) + WORD $0x3949; BYTE $0xcf // cmpq %rcx, %r15 + LONG $0x005a840f; WORD $0x0000 // je LBB11_24, $90(%rip) + LONG $0x3d4c8d4b; BYTE $0x00 // leaq (%r13,%r15), %rcx + LONG $0x04c08348 // addq $4, %rax + LONG $0x2c5c8d4b; BYTE $0x05 // leaq $5(%r12,%r13), %rbx + QUAD $0x000100002600ba48; WORD $0x0000 // movabsq $4294977024, %rdx + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 -LBB14_43: +LBB11_20: + LONG $0xff73be0f // movsbl $-1(%rbx), %esi + WORD $0xfe83; BYTE $0x20 // cmpl $32, %esi + LONG $0x003e870f; WORD $0x0000 // ja LBB11_26, $62(%rip) + LONG $0xf2a30f48 // btq %rsi, %rdx + LONG $0x0034830f; WORD $0x0000 // jae LBB11_26, $52(%rip) + WORD $0xff48; BYTE $0xc3 // incq %rbx WORD $0xff48; BYTE $0xc0 // incq %rax - WORD $0x6348; BYTE $0xd0 // movslq %eax, %rdx - WORD $0xc031 // xorl %eax, %eax - WORD $0x3948; BYTE $0xf2 // cmpq %rsi, %rdx - LONG $0x00448d0f; WORD $0x0000 // jge LBB14_53, $68(%rip) + LONG $0xffdd850f; WORD $0xffff // jne LBB11_20, $-35(%rip) + LONG $0x00000fe9; BYTE $0x00 // jmp LBB11_25, $15(%rip) -LBB14_48: - WORD $0xc031 // xorl %eax, %eax - QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90 +LBB11_23: + LONG $0xd04d8948 // movq %rcx, $-48(%rbp) + WORD $0x8949; BYTE $0xcc // movq %rcx, %r12 + LONG $0x000079e9; BYTE $0x00 // jmp LBB11_32, $121(%rip) -LBB14_49: - LONG $0x171cbe0f // movsbl (%rdi,%rdx), %ebx - WORD $0xfb83; BYTE $0x30 // cmpl $48, %ebx - LONG $0x00298c0f; WORD $0x0000 // jl LBB14_53, $41(%rip) - WORD $0xfb80; BYTE $0x39 // cmpb $57, %bl - LONG $0x0020870f; WORD $0x0000 // ja LBB14_53, $32(%rip) - LONG $0x00270f3d; BYTE $0x00 // cmpl $9999, %eax - LONG $0x00158f0f; WORD $0x0000 // jg LBB14_53, $21(%rip) - WORD $0x048d; BYTE $0x80 // leal (%rax,%rax,4), %eax - WORD $0x048d; BYTE $0x43 // leal (%rbx,%rax,2), %eax - WORD $0xc083; BYTE $0xd0 // addl $-48, %eax - WORD $0xff48; BYTE $0xc2 // incq %rdx - WORD $0x3948; BYTE $0xd6 // cmpq %rdx, %rsi - LONG $0xffca850f; WORD $0xffff // jne LBB14_49, $-54(%rip) +LBB11_24: + WORD $0x014c; BYTE $0xe9 // addq %r13, %rcx -LBB14_53: - WORD $0xaf0f; BYTE $0xc1 // imull %ecx, %eax - WORD $0x0141; BYTE $0xc0 // addl %eax, %r8d +LBB11_25: + WORD $0x294c; BYTE $0xe9 // subq %r13, %rcx + WORD $0x8948; BYTE $0xcb // movq %rcx, %rbx + WORD $0x394c; BYTE $0xfb // cmpq %r15, %rbx + LONG $0x0017820f; WORD $0x0000 // jb LBB11_27, $23(%rip) + LONG $0x000062e9; BYTE $0x00 // jmp LBB11_32, $98(%rip) -LBB14_54: - LONG $0xc4458944 // movl %r8d, $-60(%rbp) +LBB11_26: + WORD $0x894c; BYTE $0xe8 // movq %r13, %rax + WORD $0xf748; BYTE $0xd0 // notq %rax + WORD $0x0148; BYTE $0xc3 // addq %rax, %rbx + WORD $0x394c; BYTE $0xfb // cmpq %r15, %rbx + LONG $0x0050830f; WORD $0x0000 // jae LBB11_32, $80(%rip) -LBB14_55: - LONG $0xb07d8d48 // leaq $-80(%rbp), %rdi - LONG $0xd0758d48 // leaq $-48(%rbp), %rsi - WORD $0xf8c5; BYTE $0x77 // vzeroupper - LONG $0xfff4b0e8; BYTE $0xff // callq _decimal_to_f64, $-2896(%rip) - LONG $0x4510fbc5; BYTE $0xd0 // vmovsd $-48(%rbp), %xmm0 - LONG $0x28c48348 // addq $40, %rsp - BYTE $0x5b // popq %rbx - WORD $0x5c41 // popq %r12 - WORD $0x5d41 // popq %r13 - WORD $0x5e41 // popq %r14 - WORD $0x5f41 // popq %r15 - BYTE $0x5d // popq %rbp - BYTE $0xc3 // retq - QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90 +LBB11_27: + LONG $0x1d4c8a41; BYTE $0x00 // movb (%r13,%rbx), %cl -_value: - BYTE $0x55 // pushq %rbp - WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp - WORD $0x5741 // pushq %r15 - WORD $0x5641 // pushq %r14 - WORD $0x5541 // pushq %r13 - WORD $0x5441 // pushq %r12 - BYTE $0x53 // pushq %rbx - LONG $0x28ec8348 // subq $40, %rsp - WORD $0x894d; BYTE $0xc7 // movq %r8, %r15 - WORD $0x8949; BYTE $0xce // movq %rcx, %r14 - WORD $0x8948; BYTE $0xf3 // movq %rsi, %rbx - WORD $0x8949; BYTE $0xfc // movq %rdi, %r12 - LONG $0xd0558948 // movq %rdx, $-48(%rbp) - LONG $0xb07d8948 // movq %rdi, $-80(%rbp) - LONG $0xb8758948 // movq %rsi, $-72(%rbp) - LONG $0xd0558d48 // leaq $-48(%rbp), %rdx - LONG $0x0005eee8; BYTE $0x00 // callq _advance_ns, $1518(%rip) - WORD $0xbe0f; BYTE $0xc0 // movsbl %al, %eax +LBB11_28: + LONG $0x01638d4c // leaq $1(%rbx), %r12 + LONG $0xd065894c // movq %r12, $-48(%rbp) + WORD $0xbe0f; BYTE $0xc1 // movsbl %cl, %eax WORD $0xf883; BYTE $0x7d // cmpl $125, %eax - LONG $0x00bc870f; WORD $0x0000 // ja LBB15_11, $188(%rip) - LONG $0x9f0d8d48; WORD $0x0003; BYTE $0x00 // leaq $927(%rip), %rcx /* LJTI15_0(%rip) */ - LONG $0x81046348 // movslq (%rcx,%rax,4), %rax - WORD $0x0148; BYTE $0xc8 // addq %rcx, %rax + LONG $0x00c4870f; WORD $0x0000 // ja LBB11_41, $196(%rip) + LONG $0x83158d48; WORD $0x0003; BYTE $0x00 // leaq $899(%rip), %rdx /* LJTI11_0(%rip) */ + LONG $0x82046348 // movslq (%rdx,%rax,4), %rax + WORD $0x0148; BYTE $0xd0 // addq %rdx, %rax JMP AX -LBB15_2: - LONG $0xc875894c // movq %r14, $-56(%rbp) - LONG $0xd0758b4c // movq $-48(%rbp), %r14 - LONG $0xff6e8d4d // leaq $-1(%r14), %r13 - LONG $0xd06d894c // movq %r13, $-48(%rbp) - LONG $0x02c7f641 // testb $2, %r15b - LONG $0x001a850f; WORD $0x0000 // jne LBB15_4, $26(%rip) +LBB11_30: + LONG $0xd05d8948 // movq %rbx, $-48(%rbp) + LONG $0x02c0f641 // testb $2, %r8b + LONG $0x0035850f; WORD $0x0000 // jne LBB11_35, $53(%rip) LONG $0xb07d8d48 // leaq $-80(%rbp), %rdi LONG $0xd0758d48 // leaq $-48(%rbp), %rsi - LONG $0xc8558b48 // movq $-56(%rbp), %rdx - LONG $0x000dc7e8; BYTE $0x00 // callq _vnumber, $3527(%rip) - LONG $0xd07d8b4c // movq $-48(%rbp), %r15 - LONG $0x00034de9; BYTE $0x00 // jmp LBB15_58, $845(%rip) + WORD $0x894c; BYTE $0xf2 // movq %r14, %rdx + LONG $0x000b6ce8; BYTE $0x00 // callq _vnumber, $2924(%rip) + LONG $0xd05d8b48 // movq $-48(%rbp), %rbx + LONG $0x00000ae9; BYTE $0x00 // jmp LBB11_34, $10(%rip) + +LBB11_32: + LONG $0x0106c749; WORD $0x0000; BYTE $0x00 // movq $1, (%r14) -LBB15_4: +LBB11_33: + WORD $0x894c; BYTE $0xe3 // movq %r12, %rbx + +LBB11_34: + WORD $0x8948; BYTE $0xd8 // movq %rbx, %rax + LONG $0x28c48348 // addq $40, %rsp + BYTE $0x5b // popq %rbx + WORD $0x5c41 // popq %r12 + WORD $0x5d41 // popq %r13 + WORD $0x5e41 // popq %r14 + WORD $0x5f41 // popq %r15 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB11_35: + LONG $0xc875894c // movq %r14, $-56(%rbp) + LONG $0x1d748d4d; BYTE $0x00 // leaq (%r13,%rbx), %r14 WORD $0xc031 // xorl %eax, %eax - LONG $0x2c3c8043; BYTE $0x2d // cmpb $45, (%r12,%r13) - LONG $0x2c3c8d4f // leaq (%r12,%r13), %r15 + WORD $0xf980; BYTE $0x2d // cmpb $45, %cl WORD $0x940f; BYTE $0xc0 // sete %al - WORD $0x0149; BYTE $0xc7 // addq %rax, %r15 - WORD $0x2948; BYTE $0xc3 // subq %rax, %rbx - LONG $0x030c840f; WORD $0x0000 // je LBB15_53, $780(%rip) - WORD $0x3949; BYTE $0xdd // cmpq %rbx, %r13 - LONG $0x000e830f; WORD $0x0000 // jae LBB15_7, $14(%rip) - LONG $0x07b60f41 // movzbl (%r15), %eax - WORD $0xc604 // addb $-58, %al - WORD $0xf63c // cmpb $-10, %al - LONG $0x0307820f; WORD $0x0000 // jb LBB15_55, $775(%rip) + WORD $0x0149; BYTE $0xc6 // addq %rax, %r14 + WORD $0x2949; BYTE $0xc7 // subq %rax, %r15 + LONG $0x02e2840f; WORD $0x0000 // je LBB11_85, $738(%rip) + WORD $0x394c; BYTE $0xfb // cmpq %r15, %rbx + LONG $0x000d830f; WORD $0x0000 // jae LBB11_38, $13(%rip) + WORD $0x8a41; BYTE $0x06 // movb (%r14), %al + WORD $0xd004 // addb $-48, %al + WORD $0x0a3c // cmpb $10, %al + LONG $0x02e5830f; WORD $0x0000 // jae LBB11_87, $741(%rip) -LBB15_7: - WORD $0x894c; BYTE $0xff // movq %r15, %rdi - WORD $0x8948; BYTE $0xde // movq %rbx, %rsi - LONG $0x001f22e8; BYTE $0x00 // callq _do_skip_number, $7970(%rip) +LBB11_38: + WORD $0x894c; BYTE $0xf7 // movq %r14, %rdi + WORD $0x894c; BYTE $0xfe // movq %r15, %rsi + LONG $0x001f09e8; BYTE $0x00 // callq _do_skip_number, $7945(%rip) WORD $0x8548; BYTE $0xc0 // testq %rax, %rax - LONG $0x02ed880f; WORD $0x0000 // js LBB15_54, $749(%rip) - WORD $0x0149; BYTE $0xc7 // addq %rax, %r15 - WORD $0x294d; BYTE $0xe7 // subq %r12, %r15 - WORD $0x854d; BYTE $0xf6 // testq %r14, %r14 - LONG $0x02f28e0f; WORD $0x0000 // jle LBB15_57, $754(%rip) + LONG $0x02cb880f; WORD $0x0000 // js LBB11_86, $715(%rip) + WORD $0x0149; BYTE $0xc6 // addq %rax, %r14 + WORD $0x294d; BYTE $0xee // subq %r13, %r14 + LONG $0xd075894c // movq %r14, $-48(%rbp) + WORD $0x854d; BYTE $0xe4 // testq %r12, %r12 + LONG $0x02cc8e0f; WORD $0x0000 // jle LBB11_88, $716(%rip) LONG $0xc8458b48 // movq $-56(%rbp), %rax LONG $0x0800c748; WORD $0x0000; BYTE $0x00 // movq $8, (%rax) - LONG $0x1868894c // movq %r13, $24(%rax) - LONG $0x0002e5e9; BYTE $0x00 // jmp LBB15_58, $741(%rip) - -LBB15_10: - LONG $0x0106c749; WORD $0x0000; BYTE $0x00 // movq $1, (%r14) - LONG $0xd07d8b4c // movq $-48(%rbp), %r15 - LONG $0x0002d5e9; BYTE $0x00 // jmp LBB15_58, $725(%rip) + LONG $0x18588948 // movq %rbx, $24(%rax) + WORD $0x894c; BYTE $0xf3 // movq %r14, %rbx + LONG $0xffff7de9; BYTE $0xff // jmp LBB11_34, $-131(%rip) -LBB15_11: +LBB11_41: LONG $0xfe06c749; WORD $0xffff; BYTE $0xff // movq $-2, (%r14) - LONG $0xd07d8b4c // movq $-48(%rbp), %r15 - WORD $0xff49; BYTE $0xcf // decq %r15 - LONG $0x0002c2e9; BYTE $0x00 // jmp LBB15_58, $706(%rip) + LONG $0xffff71e9; BYTE $0xff // jmp LBB11_34, $-143(%rip) -LBB15_12: +LBB11_42: QUAD $0xffffffffc045c748 // movq $-1, $-64(%rbp) - LONG $0xd0658b4c // movq $-48(%rbp), %r12 LONG $0xb07d8d48 // leaq $-80(%rbp), %rdi LONG $0xc0558d48 // leaq $-64(%rbp), %rdx WORD $0x894c; BYTE $0xe6 // movq %r12, %rsi - WORD $0x894c; BYTE $0xf9 // movq %r15, %rcx - LONG $0x000814e8; BYTE $0x00 // callq _advance_string, $2068(%rip) - WORD $0x8949; BYTE $0xc7 // movq %rax, %r15 + WORD $0x894c; BYTE $0xc1 // movq %r8, %rcx + LONG $0x00054fe8; BYTE $0x00 // callq _advance_string, $1359(%rip) + WORD $0x8948; BYTE $0xc3 // movq %rax, %rbx WORD $0x8548; BYTE $0xc0 // testq %rax, %rax - LONG $0x0174880f; WORD $0x0000 // js LBB15_32, $372(%rip) - LONG $0xd07d894c // movq %r15, $-48(%rbp) + LONG $0x0150880f; WORD $0x0000 // js LBB11_61, $336(%rip) + LONG $0xd05d8948 // movq %rbx, $-48(%rbp) LONG $0x1066894d // movq %r12, $16(%r14) - LONG $0x0706c749; WORD $0x0000; BYTE $0x00 // movq $7, (%r14) LONG $0xc0458b48 // movq $-64(%rbp), %rax - WORD $0x394c; BYTE $0xf8 // cmpq %r15, %rax + WORD $0x3948; BYTE $0xd8 // cmpq %rbx, %rax LONG $0xffc1c748; WORD $0xffff; BYTE $0xff // movq $-1, %rcx LONG $0xc84c0f48 // cmovlq %rax, %rcx LONG $0x184e8949 // movq %rcx, $24(%r14) - LONG $0x00026de9; BYTE $0x00 // jmp LBB15_58, $621(%rip) + LONG $0x000007b8; BYTE $0x00 // movl $7, %eax + WORD $0x8949; BYTE $0x06 // movq %rax, (%r14) + LONG $0xffff1fe9; BYTE $0xff // jmp LBB11_34, $-225(%rip) -LBB15_14: - WORD $0xc031 // xorl %eax, %eax - LONG $0x00c7f741; WORD $0x0000; BYTE $0x80 // testl $-2147483648, %r15d - LONG $0xfec1c748; WORD $0xffff; BYTE $0xff // movq $-2, %rcx - LONG $0x00000bba; BYTE $0x00 // movl $11, %edx - LONG $0x00011ae9; BYTE $0x00 // jmp LBB15_31, $282(%rip) +LBB11_44: + WORD $0x8545; BYTE $0xc0 // testl %r8d, %r8d + LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq $-2, %rax + LONG $0x00000bb9; BYTE $0x00 // movl $11, %ecx + LONG $0x0000f8e9; BYTE $0x00 // jmp LBB11_60, $248(%rip) -LBB15_15: - WORD $0xc031 // xorl %eax, %eax - LONG $0x00c7f741; WORD $0x0000; BYTE $0x80 // testl $-2147483648, %r15d - LONG $0xfec1c748; WORD $0xffff; BYTE $0xff // movq $-2, %rcx - LONG $0x00000aba; BYTE $0x00 // movl $10, %edx - LONG $0x000100e9; BYTE $0x00 // jmp LBB15_31, $256(%rip) +LBB11_45: + WORD $0x8545; BYTE $0xc0 // testl %r8d, %r8d + LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq $-2, %rax + LONG $0x00000ab9; BYTE $0x00 // movl $10, %ecx + LONG $0x0000e4e9; BYTE $0x00 // jmp LBB11_60, $228(%rip) -LBB15_16: +LBB11_46: LONG $0x0506c749; WORD $0x0000; BYTE $0x00 // movq $5, (%r14) - LONG $0xd07d8b4c // movq $-48(%rbp), %r15 - LONG $0x000229e9; BYTE $0x00 // jmp LBB15_58, $553(%rip) + LONG $0xfffee8e9; BYTE $0xff // jmp LBB11_33, $-280(%rip) -LBB15_17: - WORD $0xc031 // xorl %eax, %eax - LONG $0x00c7f741; WORD $0x0000; BYTE $0x80 // testl $-2147483648, %r15d - LONG $0xfec1c748; WORD $0xffff; BYTE $0xff // movq $-2, %rcx - LONG $0x00000cba; BYTE $0x00 // movl $12, %edx - LONG $0x0000d6e9; BYTE $0x00 // jmp LBB15_31, $214(%rip) - -LBB15_18: - LONG $0xd07d8b4c // movq $-48(%rbp), %r15 - LONG $0xfc4b8d48 // leaq $-4(%rbx), %rcx - LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax - WORD $0x3949; BYTE $0xcf // cmpq %rcx, %r15 - LONG $0x008a870f; WORD $0x0000 // ja LBB15_25, $138(%rip) - LONG $0x3c0c8b43 // movl (%r12,%r15), %ecx - LONG $0x6c61f981; WORD $0x6573 // cmpl $1702063201, %ecx - LONG $0x00d3850f; WORD $0x0000 // jne LBB15_33, $211(%rip) - LONG $0x04c78349 // addq $4, %r15 - LONG $0x000004b8; BYTE $0x00 // movl $4, %eax - LONG $0x000069e9; BYTE $0x00 // jmp LBB15_24, $105(%rip) +LBB11_47: + WORD $0x8545; BYTE $0xc0 // testl %r8d, %r8d + LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq $-2, %rax + LONG $0x00000cb9; BYTE $0x00 // movl $12, %ecx + LONG $0x0000c4e9; BYTE $0x00 // jmp LBB11_60, $196(%rip) -LBB15_21: - LONG $0xd07d8b4c // movq $-48(%rbp), %r15 - LONG $0xfd4b8d48 // leaq $-3(%rbx), %rcx - LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax - WORD $0x3949; BYTE $0xcf // cmpq %rcx, %r15 - LONG $0x0054870f; WORD $0x0000 // ja LBB15_25, $84(%rip) - LONG $0x3c4c8b43; BYTE $0xff // movl $-1(%r12,%r15), %ecx - LONG $0x756ef981; WORD $0x6c6c // cmpl $1819047278, %ecx - LONG $0x00db850f; WORD $0x0000 // jne LBB15_37, $219(%rip) - LONG $0x03c78349 // addq $3, %r15 - LONG $0x000002b8; BYTE $0x00 // movl $2, %eax - LONG $0x000032e9; BYTE $0x00 // jmp LBB15_24, $50(%rip) +LBB11_48: + LONG $0xfc478d49 // leaq $-4(%r15), %rax + WORD $0x3948; BYTE $0xc3 // cmpq %rax, %rbx + LONG $0x008c830f; WORD $0x0000 // jae LBB11_57, $140(%rip) + LONG $0x254c8b43; BYTE $0x00 // movl (%r13,%r12), %ecx + LONG $0x6c61f981; WORD $0x6573 // cmpl $1702063201, %ecx + LONG $0x00ce850f; WORD $0x0000 // jne LBB11_62, $206(%rip) + LONG $0x05c38348 // addq $5, %rbx + LONG $0xd05d8948 // movq %rbx, $-48(%rbp) + LONG $0x000004b8; BYTE $0x00 // movl $4, %eax + WORD $0x8949; BYTE $0xdf // movq %rbx, %r15 + LONG $0x0001aae9; BYTE $0x00 // jmp LBB11_84, $426(%rip) + +LBB11_51: + LONG $0xfd478d49 // leaq $-3(%r15), %rax + WORD $0x3948; BYTE $0xc3 // cmpq %rax, %rbx + LONG $0x0059830f; WORD $0x0000 // jae LBB11_57, $89(%rip) + LONG $0x1d4c8b41; BYTE $0x00 // movl (%r13,%rbx), %ecx + LONG $0x756ef981; WORD $0x6c6c // cmpl $1819047278, %ecx + LONG $0x00da850f; WORD $0x0000 // jne LBB11_66, $218(%rip) + LONG $0x04c38348 // addq $4, %rbx + LONG $0xd05d8948 // movq %rbx, $-48(%rbp) + LONG $0x000002b8; BYTE $0x00 // movl $2, %eax + WORD $0x8949; BYTE $0xdf // movq %rbx, %r15 + LONG $0x000177e9; BYTE $0x00 // jmp LBB11_84, $375(%rip) + +LBB11_54: + LONG $0xfd478d49 // leaq $-3(%r15), %rax + WORD $0x3948; BYTE $0xc3 // cmpq %rax, %rbx + LONG $0x0026830f; WORD $0x0000 // jae LBB11_57, $38(%rip) + LONG $0x1d4c8b41; BYTE $0x00 // movl (%r13,%rbx), %ecx + LONG $0x7274f981; WORD $0x6575 // cmpl $1702195828, %ecx + LONG $0x00ea850f; WORD $0x0000 // jne LBB11_70, $234(%rip) + LONG $0x04c38348 // addq $4, %rbx + LONG $0xd05d8948 // movq %rbx, $-48(%rbp) + LONG $0x000003b8; BYTE $0x00 // movl $3, %eax + WORD $0x8949; BYTE $0xdf // movq %rbx, %r15 + LONG $0x000144e9; BYTE $0x00 // jmp LBB11_84, $324(%rip) -LBB15_26: - LONG $0xd07d8b4c // movq $-48(%rbp), %r15 - LONG $0xfd4b8d48 // leaq $-3(%rbx), %rcx +LBB11_57: + LONG $0xd07d894c // movq %r15, $-48(%rbp) LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax - WORD $0x3949; BYTE $0xcf // cmpq %rcx, %r15 - LONG $0x001d870f; WORD $0x0000 // ja LBB15_25, $29(%rip) - LONG $0x3c4c8b43; BYTE $0xff // movl $-1(%r12,%r15), %ecx - LONG $0x7274f981; WORD $0x6575 // cmpl $1702195828, %ecx - LONG $0x00e2850f; WORD $0x0000 // jne LBB15_41, $226(%rip) - LONG $0x03c78349 // addq $3, %r15 - LONG $0x000003b8; BYTE $0x00 // movl $3, %eax + LONG $0x000134e9; BYTE $0x00 // jmp LBB11_84, $308(%rip) -LBB15_24: - WORD $0x894c; BYTE $0xfb // movq %r15, %rbx +LBB11_58: + LONG $0x0606c749; WORD $0x0000; BYTE $0x00 // movq $6, (%r14) + LONG $0xfffe1fe9; BYTE $0xff // jmp LBB11_33, $-481(%rip) -LBB15_25: - LONG $0xd05d8948 // movq %rbx, $-48(%rbp) - WORD $0x8949; BYTE $0xdf // movq %rbx, %r15 - WORD $0x8949; BYTE $0x06 // movq %rax, (%r14) - LONG $0x00015ee9; BYTE $0x00 // jmp LBB15_58, $350(%rip) +LBB11_59: + WORD $0x8545; BYTE $0xc0 // testl %r8d, %r8d + LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq $-2, %rax + LONG $0x00000db9; BYTE $0x00 // movl $13, %ecx -LBB15_29: - LONG $0x0606c749; WORD $0x0000; BYTE $0x00 // movq $6, (%r14) - LONG $0xd07d8b4c // movq $-48(%rbp), %r15 - LONG $0x00014ee9; BYTE $0x00 // jmp LBB15_58, $334(%rip) +LBB11_60: + LONG $0xc8490f48 // cmovnsq %rax, %rcx + WORD $0x8949; BYTE $0x0e // movq %rcx, (%r14) + LONG $0x1ff8c141 // sarl $31, %r8d + WORD $0xf741; BYTE $0xd0 // notl %r8d + WORD $0x6349; BYTE $0xc0 // movslq %r8d, %rax + WORD $0x0149; BYTE $0xc4 // addq %rax, %r12 + LONG $0xfffdf7e9; BYTE $0xff // jmp LBB11_33, $-521(%rip) -LBB15_30: - WORD $0xc031 // xorl %eax, %eax - LONG $0x00c7f741; WORD $0x0000; BYTE $0x80 // testl $-2147483648, %r15d - LONG $0xfec1c748; WORD $0xffff; BYTE $0xff // movq $-2, %rcx - LONG $0x00000dba; BYTE $0x00 // movl $13, %edx - -LBB15_31: - LONG $0xd1440f48 // cmoveq %rcx, %rdx - WORD $0x940f; BYTE $0xc0 // sete %al - WORD $0x8949; BYTE $0x16 // movq %rdx, (%r14) - LONG $0xd07d8b4c // movq $-48(%rbp), %r15 - WORD $0x2949; BYTE $0xc7 // subq %rax, %r15 - LONG $0x000123e9; BYTE $0x00 // jmp LBB15_58, $291(%rip) - -LBB15_32: - LONG $0xd05d8948 // movq %rbx, $-48(%rbp) - WORD $0x894d; BYTE $0x3e // movq %r15, (%r14) - WORD $0x8949; BYTE $0xdf // movq %rbx, %r15 - LONG $0x000114e9; BYTE $0x00 // jmp LBB15_58, $276(%rip) +LBB11_61: + LONG $0xd07d894c // movq %r15, $-48(%rbp) + WORD $0x8949; BYTE $0x1e // movq %rbx, (%r14) + WORD $0x894c; BYTE $0xfb // movq %r15, %rbx + LONG $0xfffdebe9; BYTE $0xff // jmp LBB11_34, $-533(%rip) -LBB15_33: +LBB11_62: LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq $-2, %rax WORD $0xf980; BYTE $0x61 // cmpb $97, %cl - LONG $0x00d5850f; WORD $0x0000 // jne LBB15_49, $213(%rip) - LONG $0x3c7c8043; WORD $0x6c01 // cmpb $108, $1(%r12,%r15) - LONG $0x00aa850f; WORD $0x0000 // jne LBB15_46, $170(%rip) - LONG $0x3c7c8043; WORD $0x7302 // cmpb $115, $2(%r12,%r15) - LONG $0x00b5850f; WORD $0x0000 // jne LBB15_47, $181(%rip) - LONG $0x044f8d49 // leaq $4(%r15), %rcx - LONG $0x3c7c8043; WORD $0x6503 // cmpb $101, $3(%r12,%r15) - LONG $0x037f8d4d // leaq $3(%r15), %r15 + LONG $0x00bd850f; WORD $0x0000 // jne LBB11_74, $189(%rip) + LONG $0x1d7c8041; WORD $0x6c02 // cmpb $108, $2(%r13,%rbx) + LONG $0x00c1850f; WORD $0x0000 // jne LBB11_81, $193(%rip) + LONG $0x1d7c8041; WORD $0x7303 // cmpb $115, $3(%r13,%rbx) + LONG $0x00be850f; WORD $0x0000 // jne LBB11_79, $190(%rip) + LONG $0x047b8d4c // leaq $4(%rbx), %r15 + LONG $0x054b8d48 // leaq $5(%rbx), %rcx + LONG $0x1d7c8041; WORD $0x6504 // cmpb $101, $4(%r13,%rbx) LONG $0xf9440f4c // cmoveq %rcx, %r15 - LONG $0x0000a2e9; BYTE $0x00 // jmp LBB15_48, $162(%rip) + LONG $0x0000aee9; BYTE $0x00 // jmp LBB11_83, $174(%rip) -LBB15_37: +LBB11_66: + LONG $0xd05d8948 // movq %rbx, $-48(%rbp) LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq $-2, %rax WORD $0xf980; BYTE $0x6e // cmpb $110, %cl - LONG $0x006c850f; WORD $0x0000 // jne LBB15_45, $108(%rip) - LONG $0x3c3c8043; BYTE $0x75 // cmpb $117, (%r12,%r15) - LONG $0x0077850f; WORD $0x0000 // jne LBB15_51, $119(%rip) - LONG $0x3c7c8043; WORD $0x6c01 // cmpb $108, $1(%r12,%r15) - LONG $0x0068850f; WORD $0x0000 // jne LBB15_50, $104(%rip) - LONG $0x034f8d49 // leaq $3(%r15), %rcx - LONG $0x3c7c8043; WORD $0x6c02 // cmpb $108, $2(%r12,%r15) - LONG $0x027f8d4d // leaq $2(%r15), %r15 + LONG $0x0072850f; WORD $0x0000 // jne LBB11_76, $114(%rip) + LONG $0x1d7c8041; WORD $0x7501 // cmpb $117, $1(%r13,%rbx) + LONG $0x0076850f; WORD $0x0000 // jne LBB11_77, $118(%rip) + LONG $0x1d7c8041; WORD $0x6c02 // cmpb $108, $2(%r13,%rbx) + LONG $0x0072850f; WORD $0x0000 // jne LBB11_81, $114(%rip) + LONG $0x037b8d4c // leaq $3(%rbx), %r15 + LONG $0x044b8d48 // leaq $4(%rbx), %rcx + LONG $0x1d7c8041; WORD $0x6c03 // cmpb $108, $3(%r13,%rbx) LONG $0xf9440f4c // cmoveq %rcx, %r15 - LONG $0x000054e9; BYTE $0x00 // jmp LBB15_51, $84(%rip) + LONG $0x00006be9; BYTE $0x00 // jmp LBB11_83, $107(%rip) -LBB15_41: +LBB11_70: + LONG $0xd05d8948 // movq %rbx, $-48(%rbp) LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq $-2, %rax WORD $0xf980; BYTE $0x74 // cmpb $116, %cl - LONG $0x002e850f; WORD $0x0000 // jne LBB15_45, $46(%rip) - LONG $0x3c3c8043; BYTE $0x72 // cmpb $114, (%r12,%r15) - LONG $0x0039850f; WORD $0x0000 // jne LBB15_51, $57(%rip) - LONG $0x3c7c8043; WORD $0x7501 // cmpb $117, $1(%r12,%r15) - LONG $0x002a850f; WORD $0x0000 // jne LBB15_50, $42(%rip) - LONG $0x034f8d49 // leaq $3(%r15), %rcx - LONG $0x3c7c8043; WORD $0x6502 // cmpb $101, $2(%r12,%r15) - LONG $0x027f8d4d // leaq $2(%r15), %r15 + LONG $0x002f850f; WORD $0x0000 // jne LBB11_76, $47(%rip) + LONG $0x1d7c8041; WORD $0x7201 // cmpb $114, $1(%r13,%rbx) + LONG $0x0033850f; WORD $0x0000 // jne LBB11_77, $51(%rip) + LONG $0x1d7c8041; WORD $0x7502 // cmpb $117, $2(%r13,%rbx) + LONG $0x002f850f; WORD $0x0000 // jne LBB11_81, $47(%rip) + LONG $0x037b8d4c // leaq $3(%rbx), %r15 + LONG $0x044b8d48 // leaq $4(%rbx), %rcx + LONG $0x1d7c8041; WORD $0x6503 // cmpb $101, $3(%r13,%rbx) LONG $0xf9440f4c // cmoveq %rcx, %r15 - LONG $0x000016e9; BYTE $0x00 // jmp LBB15_51, $22(%rip) + LONG $0x000028e9; BYTE $0x00 // jmp LBB11_83, $40(%rip) -LBB15_45: - WORD $0xff49; BYTE $0xcf // decq %r15 - WORD $0x8949; BYTE $0x06 // movq %rax, (%r14) - LONG $0x00004ee9; BYTE $0x00 // jmp LBB15_58, $78(%rip) +LBB11_76: + WORD $0x8949; BYTE $0xdf // movq %rbx, %r15 + LONG $0x000024e9; BYTE $0x00 // jmp LBB11_84, $36(%rip) -LBB15_46: - WORD $0xff49; BYTE $0xc7 // incq %r15 - LONG $0x000013e9; BYTE $0x00 // jmp LBB15_48, $19(%rip) +LBB11_74: + WORD $0x894d; BYTE $0xe7 // movq %r12, %r15 + LONG $0x00001ce9; BYTE $0x00 // jmp LBB11_84, $28(%rip) -LBB15_50: - WORD $0xff49; BYTE $0xc7 // incq %r15 +LBB11_77: + WORD $0xff48; BYTE $0xc3 // incq %rbx + LONG $0x00000de9; BYTE $0x00 // jmp LBB11_82, $13(%rip) -LBB15_51: - LONG $0xd07d894c // movq %r15, $-48(%rbp) - WORD $0x8949; BYTE $0x06 // movq %rax, (%r14) - LONG $0x000037e9; BYTE $0x00 // jmp LBB15_58, $55(%rip) +LBB11_81: + LONG $0x02c38348 // addq $2, %rbx + LONG $0x000004e9; BYTE $0x00 // jmp LBB11_82, $4(%rip) + +LBB11_79: + LONG $0x03c38348 // addq $3, %rbx -LBB15_47: - LONG $0x02c78349 // addq $2, %r15 +LBB11_82: + WORD $0x8949; BYTE $0xdf // movq %rbx, %r15 -LBB15_48: +LBB11_83: LONG $0xd07d894c // movq %r15, $-48(%rbp) -LBB15_49: +LBB11_84: WORD $0x8949; BYTE $0x06 // movq %rax, (%r14) - LONG $0x000027e9; BYTE $0x00 // jmp LBB15_58, $39(%rip) + WORD $0x894c; BYTE $0xfb // movq %r15, %rbx + LONG $0xfffcefe9; BYTE $0xff // jmp LBB11_34, $-785(%rip) -LBB15_53: - LONG $0xffc5c749; WORD $0xffff; BYTE $0xff // movq $-1, %r13 - LONG $0x00000de9; BYTE $0x00 // jmp LBB15_56, $13(%rip) +LBB11_85: + WORD $0x294d; BYTE $0xee // subq %r13, %r14 + LONG $0xd075894c // movq %r14, $-48(%rbp) + LONG $0xffc3c748; WORD $0xffff; BYTE $0xff // movq $-1, %rbx + LONG $0x000014e9; BYTE $0x00 // jmp LBB11_88, $20(%rip) -LBB15_54: +LBB11_86: WORD $0xf748; BYTE $0xd0 // notq %rax - WORD $0x0149; BYTE $0xc7 // addq %rax, %r15 - -LBB15_55: - LONG $0xfec5c749; WORD $0xffff; BYTE $0xff // movq $-2, %r13 - -LBB15_56: - WORD $0x294d; BYTE $0xe7 // subq %r12, %r15 - LONG $0xd07d894c // movq %r15, $-48(%rbp) - -LBB15_57: - LONG $0xc8458b48 // movq $-56(%rbp), %rax - WORD $0x894c; BYTE $0x28 // movq %r13, (%rax) - -LBB15_58: - WORD $0x894c; BYTE $0xf8 // movq %r15, %rax - LONG $0x28c48348 // addq $40, %rsp - BYTE $0x5b // popq %rbx - WORD $0x5c41 // popq %r12 - WORD $0x5d41 // popq %r13 - WORD $0x5e41 // popq %r14 - WORD $0x5f41 // popq %r15 - BYTE $0x5d // popq %rbp - BYTE $0xc3 // retq - WORD $0x9090; BYTE $0x90 // .p2align 2, 0x90 - - // .set L15_0_set_10, LBB15_10-LJTI15_0 - // .set L15_0_set_11, LBB15_11-LJTI15_0 - // .set L15_0_set_12, LBB15_12-LJTI15_0 - // .set L15_0_set_14, LBB15_14-LJTI15_0 - // .set L15_0_set_2, LBB15_2-LJTI15_0 - // .set L15_0_set_15, LBB15_15-LJTI15_0 - // .set L15_0_set_16, LBB15_16-LJTI15_0 - // .set L15_0_set_17, LBB15_17-LJTI15_0 - // .set L15_0_set_18, LBB15_18-LJTI15_0 - // .set L15_0_set_21, LBB15_21-LJTI15_0 - // .set L15_0_set_26, LBB15_26-LJTI15_0 - // .set L15_0_set_29, LBB15_29-LJTI15_0 - // .set L15_0_set_30, LBB15_30-LJTI15_0 -LJTI15_0: - LONG $0xfffffd06 // .long L15_0_set_10 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd29 // .long L15_0_set_12 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd7e // .long L15_0_set_14 - LONG $0xfffffc6a // .long L15_0_set_2 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffc6a // .long L15_0_set_2 - LONG $0xfffffc6a // .long L15_0_set_2 - LONG $0xfffffc6a // .long L15_0_set_2 - LONG $0xfffffc6a // .long L15_0_set_2 - LONG $0xfffffc6a // .long L15_0_set_2 - LONG $0xfffffc6a // .long L15_0_set_2 - LONG $0xfffffc6a // .long L15_0_set_2 - LONG $0xfffffc6a // .long L15_0_set_2 - LONG $0xfffffc6a // .long L15_0_set_2 - LONG $0xfffffc6a // .long L15_0_set_2 - LONG $0xfffffd98 // .long L15_0_set_15 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffdb2 // .long L15_0_set_16 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffdc2 // .long L15_0_set_17 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffddc // .long L15_0_set_18 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffe12 // .long L15_0_set_21 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffe49 // .long L15_0_set_26 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffe8d // .long L15_0_set_29 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffe9d // .long L15_0_set_30 - LONG $0x00000000 // .p2align 4, 0x00 - -LCPI16_0: - QUAD $0x2020202020202020; QUAD $0x2020202020202020 // .space 16, ' ' - -LCPI16_1: - QUAD $0x0909090909090909; QUAD $0x0909090909090909 // .space 16, '\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t' - -LCPI16_2: - QUAD $0x0a0a0a0a0a0a0a0a; QUAD $0x0a0a0a0a0a0a0a0a // .space 16, '\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n' - -LCPI16_3: - QUAD $0x0d0d0d0d0d0d0d0d; QUAD $0x0d0d0d0d0d0d0d0d // .space 16, '\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r' - - // .p2align 4, 0x90 -_advance_ns: - BYTE $0x55 // pushq %rbp - WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp - WORD $0x8b4c; BYTE $0x02 // movq (%rdx), %r8 - WORD $0x3949; BYTE $0xf0 // cmpq %rsi, %r8 - LONG $0x0029830f; WORD $0x0000 // jae LBB16_6, $41(%rip) - LONG $0x04b60f42; BYTE $0x07 // movzbl (%rdi,%r8), %eax - WORD $0xf883; BYTE $0x0d // cmpl $13, %eax - LONG $0x001b840f; WORD $0x0000 // je LBB16_6, $27(%rip) - WORD $0xf883; BYTE $0x20 // cmpl $32, %eax - LONG $0x0012840f; WORD $0x0000 // je LBB16_6, $18(%rip) - WORD $0xf504 // addb $-11, %al - WORD $0xfe3c // cmpb $-2, %al - LONG $0x0008830f; WORD $0x0000 // jae LBB16_6, $8(%rip) - WORD $0x894c; BYTE $0xc0 // movq %r8, %rax - LONG $0x000207e9; BYTE $0x00 // jmp LBB16_5, $519(%rip) - -LBB16_6: - LONG $0x01408d49 // leaq $1(%r8), %rax - WORD $0x3948; BYTE $0xf0 // cmpq %rsi, %rax - LONG $0x0022830f; WORD $0x0000 // jae LBB16_10, $34(%rip) - LONG $0x070cb60f // movzbl (%rdi,%rax), %ecx - WORD $0xf983; BYTE $0x0d // cmpl $13, %ecx - LONG $0x0015840f; WORD $0x0000 // je LBB16_10, $21(%rip) - WORD $0xf983; BYTE $0x20 // cmpl $32, %ecx - LONG $0x000c840f; WORD $0x0000 // je LBB16_10, $12(%rip) - WORD $0xc180; BYTE $0xf5 // addb $-11, %cl - WORD $0xf980; BYTE $0xfe // cmpb $-2, %cl - LONG $0x01d8820f; WORD $0x0000 // jb LBB16_5, $472(%rip) - -LBB16_10: - LONG $0x02408d49 // leaq $2(%r8), %rax - WORD $0x3948; BYTE $0xf0 // cmpq %rsi, %rax - LONG $0x0022830f; WORD $0x0000 // jae LBB16_14, $34(%rip) - LONG $0x070cb60f // movzbl (%rdi,%rax), %ecx - WORD $0xf983; BYTE $0x0d // cmpl $13, %ecx - LONG $0x0015840f; WORD $0x0000 // je LBB16_14, $21(%rip) - WORD $0xf983; BYTE $0x20 // cmpl $32, %ecx - LONG $0x000c840f; WORD $0x0000 // je LBB16_14, $12(%rip) - WORD $0xc180; BYTE $0xf5 // addb $-11, %cl - WORD $0xf980; BYTE $0xfe // cmpb $-2, %cl - LONG $0x01a9820f; WORD $0x0000 // jb LBB16_5, $425(%rip) - -LBB16_14: - LONG $0x03408d49 // leaq $3(%r8), %rax - WORD $0x3948; BYTE $0xf0 // cmpq %rsi, %rax - LONG $0x0022830f; WORD $0x0000 // jae LBB16_18, $34(%rip) - LONG $0x070cb60f // movzbl (%rdi,%rax), %ecx - WORD $0xf983; BYTE $0x0d // cmpl $13, %ecx - LONG $0x0015840f; WORD $0x0000 // je LBB16_18, $21(%rip) - WORD $0xf983; BYTE $0x20 // cmpl $32, %ecx - LONG $0x000c840f; WORD $0x0000 // je LBB16_18, $12(%rip) - WORD $0xc180; BYTE $0xf5 // addb $-11, %cl - WORD $0xf980; BYTE $0xfe // cmpb $-2, %cl - LONG $0x017a820f; WORD $0x0000 // jb LBB16_5, $378(%rip) - -LBB16_18: - LONG $0x04c08349 // addq $4, %r8 - WORD $0x3949; BYTE $0xf0 // cmpq %rsi, %r8 - LONG $0x014d830f; WORD $0x0000 // jae LBB16_19, $333(%rip) - LONG $0x070c8d4e // leaq (%rdi,%r8), %r9 - WORD $0x8949; BYTE $0xf3 // movq %rsi, %r11 - WORD $0x294d; BYTE $0xc3 // subq %r8, %r11 - LONG $0x0073840f; WORD $0x0000 // je LBB16_27, $115(%rip) - WORD $0x8944; BYTE $0xc8 // movl %r9d, %eax - WORD $0xe083; BYTE $0x0f // andl $15, %eax - LONG $0x0067840f; WORD $0x0000 // je LBB16_27, $103(%rip) - LONG $0x0005ba41; WORD $0x0000 // movl $5, %r10d - WORD $0x2949; BYTE $0xf2 // subq %rsi, %r10 - QUAD $0x000100002600b949; WORD $0x0000 // movabsq $4294977024, %r9 - QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 - -LBB16_23: - LONG $0x0cbe0f42; BYTE $0x07 // movsbl (%rdi,%r8), %ecx - WORD $0xf983; BYTE $0x20 // cmpl $32, %ecx - LONG $0x0116870f; WORD $0x0000 // ja LBB16_42, $278(%rip) - LONG $0xc9a30f49 // btq %rcx, %r9 - LONG $0x010c830f; WORD $0x0000 // jae LBB16_42, $268(%rip) - LONG $0x02048d4b // leaq (%r10,%r8), %rax - LONG $0x01488d49 // leaq $1(%r8), %rcx - LONG $0x04f88348 // cmpq $4, %rax - LONG $0x0012840f; WORD $0x0000 // je LBB16_26, $18(%rip) - LONG $0x07048d42 // leal (%rdi,%r8), %eax - WORD $0xc0ff // incl %eax - WORD $0x8949; BYTE $0xc8 // movq %rcx, %r8 - WORD $0xe083; BYTE $0x0f // andl $15, %eax - LONG $0xffc4850f; WORD $0xffff // jne LBB16_23, $-60(%rip) - -LBB16_26: - LONG $0x0f0c8d4c // leaq (%rdi,%rcx), %r9 - WORD $0x8949; BYTE $0xf3 // movq %rsi, %r11 - WORD $0x2949; BYTE $0xcb // subq %rcx, %r11 - -LBB16_27: - LONG $0x10fb8349 // cmpq $16, %r11 - LONG $0x0075820f; WORD $0x0000 // jb LBB16_33, $117(%rip) - WORD $0x8948; BYTE $0xf9 // movq %rdi, %rcx - WORD $0x294c; BYTE $0xc9 // subq %r9, %rcx - QUAD $0xfffffe52056ff9c5 // vmovdqa $-430(%rip), %xmm0 /* LCPI16_0(%rip) */ - QUAD $0xfffffe5a0d6ff9c5 // vmovdqa $-422(%rip), %xmm1 /* LCPI16_1(%rip) */ - QUAD $0xfffffe62156ff9c5 // vmovdqa $-414(%rip), %xmm2 /* LCPI16_2(%rip) */ - QUAD $0xfffffe6a1d6ff9c5 // vmovdqa $-406(%rip), %xmm3 /* LCPI16_3(%rip) */ - QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90 - -LBB16_29: - LONG $0x6f79c1c4; BYTE $0x21 // vmovdqa (%r9), %xmm4 - LONG $0xe874d9c5 // vpcmpeqb %xmm0, %xmm4, %xmm5 - LONG $0xf174d9c5 // vpcmpeqb %xmm1, %xmm4, %xmm6 - LONG $0xeeebd1c5 // vpor %xmm6, %xmm5, %xmm5 - LONG $0xf274d9c5 // vpcmpeqb %xmm2, %xmm4, %xmm6 - LONG $0xe374d9c5 // vpcmpeqb %xmm3, %xmm4, %xmm4 - LONG $0xe6ebd9c5 // vpor %xmm6, %xmm4, %xmm4 - LONG $0xe5ebd9c5 // vpor %xmm5, %xmm4, %xmm4 - LONG $0xc4d7f9c5 // vpmovmskb %xmm4, %eax - LONG $0xfff88366 // cmpw $-1, %ax - LONG $0x0069850f; WORD $0x0000 // jne LBB16_30, $105(%rip) - LONG $0x10c18349 // addq $16, %r9 - LONG $0xf0c38349 // addq $-16, %r11 - LONG $0xf0c18348 // addq $-16, %rcx - LONG $0x0ffb8349 // cmpq $15, %r11 - LONG $0xffbb870f; WORD $0xffff // ja LBB16_29, $-69(%rip) - -LBB16_33: - WORD $0x854d; BYTE $0xdb // testq %r11, %r11 - LONG $0x0037840f; WORD $0x0000 // je LBB16_40, $55(%rip) - LONG $0x19048d4f // leaq (%r9,%r11), %r8 - WORD $0xc931 // xorl %ecx, %ecx - QUAD $0x000100002600ba49; WORD $0x0000 // movabsq $4294977024, %r10 - -LBB16_35: - LONG $0x04be0f41; BYTE $0x09 // movsbl (%r9,%rcx), %eax - WORD $0xf883; BYTE $0x20 // cmpl $32, %eax - LONG $0x005b870f; WORD $0x0000 // ja LBB16_37, $91(%rip) - LONG $0xc2a30f49 // btq %rax, %r10 - LONG $0x0051830f; WORD $0x0000 // jae LBB16_37, $81(%rip) - WORD $0xff48; BYTE $0xc1 // incq %rcx - WORD $0x3949; BYTE $0xcb // cmpq %rcx, %r11 - LONG $0xffdc850f; WORD $0xffff // jne LBB16_35, $-36(%rip) - WORD $0x894d; BYTE $0xc1 // movq %r8, %r9 - -LBB16_40: - WORD $0x2949; BYTE $0xf9 // subq %rdi, %r9 - -LBB16_41: - WORD $0x894d; BYTE $0xc8 // movq %r9, %r8 - LONG $0x000014e9; BYTE $0x00 // jmp LBB16_42, $20(%rip) - -LBB16_19: - WORD $0x894c; BYTE $0x02 // movq %r8, (%rdx) - LONG $0x000028e9; BYTE $0x00 // jmp LBB16_43, $40(%rip) - -LBB16_30: - WORD $0xb70f; BYTE $0xc0 // movzwl %ax, %eax - WORD $0xd0f7 // notl %eax - LONG $0xc0bc0f44 // bsfl %eax, %r8d - WORD $0x2949; BYTE $0xc8 // subq %rcx, %r8 - -LBB16_42: - WORD $0x894c; BYTE $0xc0 // movq %r8, %rax - WORD $0x3949; BYTE $0xf0 // cmpq %rsi, %r8 - LONG $0x0010830f; WORD $0x0000 // jae LBB16_43, $16(%rip) - -LBB16_5: - LONG $0x01488d48 // leaq $1(%rax), %rcx - WORD $0x8948; BYTE $0x0a // movq %rcx, (%rdx) - LONG $0x0704b60f // movzbl (%rdi,%rax), %eax - WORD $0xbe0f; BYTE $0xc0 // movsbl %al, %eax - BYTE $0x5d // popq %rbp - BYTE $0xc3 // retq + WORD $0x0149; BYTE $0xc6 // addq %rax, %r14 -LBB16_43: - WORD $0xc031 // xorl %eax, %eax - WORD $0xbe0f; BYTE $0xc0 // movsbl %al, %eax - BYTE $0x5d // popq %rbp - BYTE $0xc3 // retq +LBB11_87: + WORD $0x294d; BYTE $0xee // subq %r13, %r14 + LONG $0xd075894c // movq %r14, $-48(%rbp) + LONG $0xfec3c748; WORD $0xffff; BYTE $0xff // movq $-2, %rbx -LBB16_37: - WORD $0x2949; BYTE $0xf9 // subq %rdi, %r9 - WORD $0x0149; BYTE $0xc9 // addq %rcx, %r9 - LONG $0xffffb6e9; BYTE $0xff // jmp LBB16_41, $-74(%rip) - QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 +LBB11_88: + LONG $0xc8458b48 // movq $-56(%rbp), %rax + WORD $0x8948; BYTE $0x18 // movq %rbx, (%rax) + WORD $0x894c; BYTE $0xf3 // movq %r14, %rbx + LONG $0xfffcb9e9; BYTE $0xff // jmp LBB11_34, $-839(%rip) + WORD $0x9090 // .p2align 2, 0x90 + + // .set L11_0_set_32, LBB11_32-LJTI11_0 + // .set L11_0_set_41, LBB11_41-LJTI11_0 + // .set L11_0_set_42, LBB11_42-LJTI11_0 + // .set L11_0_set_44, LBB11_44-LJTI11_0 + // .set L11_0_set_30, LBB11_30-LJTI11_0 + // .set L11_0_set_45, LBB11_45-LJTI11_0 + // .set L11_0_set_46, LBB11_46-LJTI11_0 + // .set L11_0_set_47, LBB11_47-LJTI11_0 + // .set L11_0_set_48, LBB11_48-LJTI11_0 + // .set L11_0_set_51, LBB11_51-LJTI11_0 + // .set L11_0_set_54, LBB11_54-LJTI11_0 + // .set L11_0_set_58, LBB11_58-LJTI11_0 + // .set L11_0_set_59, LBB11_59-LJTI11_0 +LJTI11_0: + LONG $0xfffffcad // .long L11_0_set_32 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd46 // .long L11_0_set_42 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd98 // .long L11_0_set_44 + LONG $0xfffffc86 // .long L11_0_set_30 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffc86 // .long L11_0_set_30 + LONG $0xfffffc86 // .long L11_0_set_30 + LONG $0xfffffc86 // .long L11_0_set_30 + LONG $0xfffffc86 // .long L11_0_set_30 + LONG $0xfffffc86 // .long L11_0_set_30 + LONG $0xfffffc86 // .long L11_0_set_30 + LONG $0xfffffc86 // .long L11_0_set_30 + LONG $0xfffffc86 // .long L11_0_set_30 + LONG $0xfffffc86 // .long L11_0_set_30 + LONG $0xfffffc86 // .long L11_0_set_30 + LONG $0xfffffdac // .long L11_0_set_45 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffdc0 // .long L11_0_set_46 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffdcc // .long L11_0_set_47 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffde0 // .long L11_0_set_48 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffe13 // .long L11_0_set_51 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffe46 // .long L11_0_set_54 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffe89 // .long L11_0_set_58 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffe95 // .long L11_0_set_59 + QUAD $0x9090909090909090 // .p2align 4, 0x90 _vstring: BYTE $0x55 // pushq %rbp @@ -4840,185 +4074,197 @@ _vstring: WORD $0x894c; BYTE $0xe6 // movq %r12, %rsi LONG $0x000081e8; BYTE $0x00 // callq _advance_string, $129(%rip) WORD $0x8548; BYTE $0xc0 // testq %rax, %rax - LONG $0x0029880f; WORD $0x0000 // js LBB17_1, $41(%rip) + LONG $0x0027880f; WORD $0x0000 // js LBB12_1, $39(%rip) WORD $0x8948; BYTE $0x03 // movq %rax, (%rbx) LONG $0x1066894d // movq %r12, $16(%r14) - LONG $0x0706c749; WORD $0x0000; BYTE $0x00 // movq $7, (%r14) LONG $0xd84d8b48 // movq $-40(%rbp), %rcx WORD $0x3948; BYTE $0xc1 // cmpq %rax, %rcx LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax LONG $0xc14c0f48 // cmovlq %rcx, %rax LONG $0x18468949 // movq %rax, $24(%r14) - LONG $0x00000ae9; BYTE $0x00 // jmp LBB17_3, $10(%rip) + LONG $0x000007b8; BYTE $0x00 // movl $7, %eax + LONG $0x000007e9; BYTE $0x00 // jmp LBB12_3, $7(%rip) -LBB17_1: +LBB12_1: LONG $0x084f8b49 // movq $8(%r15), %rcx WORD $0x8948; BYTE $0x0b // movq %rcx, (%rbx) - WORD $0x8949; BYTE $0x06 // movq %rax, (%r14) -LBB17_3: - LONG $0x10c48348 // addq $16, %rsp - BYTE $0x5b // popq %rbx - WORD $0x5c41 // popq %r12 - WORD $0x5e41 // popq %r14 - WORD $0x5f41 // popq %r15 - BYTE $0x5d // popq %rbp - BYTE $0xc3 // retq - QUAD $0x0000000000000000 // .p2align 4, 0x00 +LBB12_3: + WORD $0x8949; BYTE $0x06 // movq %rax, (%r14) + LONG $0x10c48348 // addq $16, %rsp + BYTE $0x5b // popq %rbx + WORD $0x5c41 // popq %r12 + WORD $0x5e41 // popq %r14 + WORD $0x5f41 // popq %r15 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + QUAD $0x0000000000000000; WORD $0x0000 // .p2align 4, 0x00 -LCPI18_0: +LCPI13_0: QUAD $0x2222222222222222; QUAD $0x2222222222222222 // .space 16, '""""""""""""""""' -LCPI18_1: +LCPI13_1: QUAD $0x5c5c5c5c5c5c5c5c; QUAD $0x5c5c5c5c5c5c5c5c // .space 16, '\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' -LCPI18_2: - QUAD $0x1f1f1f1f1f1f1f1f; QUAD $0x1f1f1f1f1f1f1f1f // .space 16, '\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f' +LCPI13_2: + QUAD $0x2020202020202020; QUAD $0x2020202020202020 // .space 16, ' ' // .p2align 4, 0x90 _advance_string: WORD $0xc1f6; BYTE $0x20 // testb $32, %cl - LONG $0x0005850f; WORD $0x0000 // jne LBB18_2, $5(%rip) - LONG $0x004572e9; BYTE $0x00 // jmp _advance_string_default, $17778(%rip) + LONG $0x0005850f; WORD $0x0000 // jne LBB13_2, $5(%rip) + LONG $0x005552e9; BYTE $0x00 // jmp _advance_string_default, $21842(%rip) -LBB18_2: - BYTE $0x55 // pushq %rbp - WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp - WORD $0x5741 // pushq %r15 - WORD $0x5641 // pushq %r14 - WORD $0x5541 // pushq %r13 - WORD $0x5441 // pushq %r12 - BYTE $0x53 // pushq %rbx - LONG $0x18ec8348 // subq $24, %rsp - LONG $0x087f8b4c // movq $8(%rdi), %r15 - WORD $0x2949; BYTE $0xf7 // subq %rsi, %r15 - LONG $0x0483840f; WORD $0x0000 // je LBB18_47, $1155(%rip) - WORD $0x8b48; BYTE $0x07 // movq (%rdi), %rax - LONG $0xd0458948 // movq %rax, $-48(%rbp) - LONG $0xc0558948 // movq %rdx, $-64(%rbp) - LONG $0xff02c748; WORD $0xffff; BYTE $0xff // movq $-1, (%rdx) - LONG $0x40ff8349 // cmpq $64, %r15 - LONG $0x0390820f; WORD $0x0000 // jb LBB18_48, $912(%rip) - QUAD $0xffffffffc845c748 // movq $-1, $-56(%rbp) - WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d - QUAD $0xffffff75056ff9c5 // vmovdqa $-139(%rip), %xmm0 /* LCPI18_0(%rip) */ - QUAD $0xffffff7d0d6ff9c5 // vmovdqa $-131(%rip), %xmm1 /* LCPI18_1(%rip) */ - QUAD $0xffffff85156ff9c5 // vmovdqa $-123(%rip), %xmm2 /* LCPI18_2(%rip) */ - LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 +LBB13_2: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5741 // pushq %r15 + WORD $0x5641 // pushq %r14 + WORD $0x5541 // pushq %r13 + WORD $0x5441 // pushq %r12 + BYTE $0x53 // pushq %rbx + LONG $0x20ec8348 // subq $32, %rsp + LONG $0x085f8b48 // movq $8(%rdi), %rbx + WORD $0x2948; BYTE $0xf3 // subq %rsi, %rbx + LONG $0x04d4840f; WORD $0x0000 // je LBB13_21, $1236(%rip) + WORD $0x8b48; BYTE $0x07 // movq (%rdi), %rax + LONG $0xc0458948 // movq %rax, $-64(%rbp) + WORD $0x0148; BYTE $0xc6 // addq %rax, %rsi + LONG $0xc8558948 // movq %rdx, $-56(%rbp) + LONG $0xff02c748; WORD $0xffff; BYTE $0xff // movq $-1, (%rdx) + LONG $0x40fb8348 // cmpq $64, %rbx + LONG $0x024a820f; WORD $0x0000 // jb LBB13_22, $586(%rip) + QUAD $0xffffffffd045c748 // movq $-1, $-48(%rbp) + WORD $0x3145; BYTE $0xff // xorl %r15d, %r15d + QUAD $0xffffff72056f79c5 // vmovdqa $-142(%rip), %xmm8 /* LCPI13_0(%rip) */ + QUAD $0xffffff7a0d6ff9c5 // vmovdqa $-134(%rip), %xmm1 /* LCPI13_1(%rip) */ + QUAD $0xffffff82156ff9c5 // vmovdqa $-126(%rip), %xmm2 /* LCPI13_2(%rip) */ + LONG $0xdb76e1c5 // vpcmpeqd %xmm3, %xmm3, %xmm3 + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 -LBB18_5: - LONG $0xd0458b48 // movq $-48(%rbp), %rax - LONG $0x1c6ffac5; BYTE $0x30 // vmovdqu (%rax,%rsi), %xmm3 - LONG $0x646ffac5; WORD $0x1030 // vmovdqu $16(%rax,%rsi), %xmm4 - LONG $0x6c6ffac5; WORD $0x2030 // vmovdqu $32(%rax,%rsi), %xmm5 - LONG $0x746ffac5; WORD $0x3030 // vmovdqu $48(%rax,%rsi), %xmm6 - LONG $0xf874e1c5 // vpcmpeqb %xmm0, %xmm3, %xmm7 - LONG $0xe7d779c5 // vpmovmskb %xmm7, %r12d - LONG $0xf874d9c5 // vpcmpeqb %xmm0, %xmm4, %xmm7 - LONG $0xcfd779c5 // vpmovmskb %xmm7, %r9d - LONG $0xf874d1c5 // vpcmpeqb %xmm0, %xmm5, %xmm7 - LONG $0xdfd779c5 // vpmovmskb %xmm7, %r11d - LONG $0xf874c9c5 // vpcmpeqb %xmm0, %xmm6, %xmm7 - LONG $0xd7d7f9c5 // vpmovmskb %xmm7, %edx - LONG $0xf974e1c5 // vpcmpeqb %xmm1, %xmm3, %xmm7 - LONG $0xefd779c5 // vpmovmskb %xmm7, %r13d - LONG $0xf974d9c5 // vpcmpeqb %xmm1, %xmm4, %xmm7 - LONG $0xcfd7f9c5 // vpmovmskb %xmm7, %ecx - LONG $0xf974d1c5 // vpcmpeqb %xmm1, %xmm5, %xmm7 - LONG $0xffd7f9c5 // vpmovmskb %xmm7, %edi - LONG $0xf974c9c5 // vpcmpeqb %xmm1, %xmm6, %xmm7 - LONG $0xd7d779c5 // vpmovmskb %xmm7, %r10d - LONG $0xfadad9c5 // vpminub %xmm2, %xmm4, %xmm7 - LONG $0xe774d9c5 // vpcmpeqb %xmm7, %xmm4, %xmm4 - LONG $0xdcd7f9c5 // vpmovmskb %xmm4, %ebx - LONG $0xe2dad1c5 // vpminub %xmm2, %xmm5, %xmm4 - LONG $0xe474d1c5 // vpcmpeqb %xmm4, %xmm5, %xmm4 - LONG $0xc4d7f9c5 // vpmovmskb %xmm4, %eax - LONG $0xe2dac9c5 // vpminub %xmm2, %xmm6, %xmm4 - LONG $0xe474c9c5 // vpcmpeqb %xmm4, %xmm6, %xmm4 - LONG $0xc4d779c5 // vpmovmskb %xmm4, %r8d - LONG $0x30e2c148 // shlq $48, %rdx - LONG $0x20e3c149 // shlq $32, %r11 - WORD $0x0949; BYTE $0xd3 // orq %rdx, %r11 +LBB13_5: + LONG $0xb85d8948 // movq %rbx, $-72(%rbp) + LONG $0x266ffac5 // vmovdqu (%rsi), %xmm4 + LONG $0x6e6ffac5; BYTE $0x10 // vmovdqu $16(%rsi), %xmm5 + LONG $0x766ffac5; BYTE $0x20 // vmovdqu $32(%rsi), %xmm6 + LONG $0x7e6ffac5; BYTE $0x30 // vmovdqu $48(%rsi), %xmm7 + LONG $0xc474b9c5 // vpcmpeqb %xmm4, %xmm8, %xmm0 + LONG $0xe8d779c5 // vpmovmskb %xmm0, %r13d + LONG $0xc574b9c5 // vpcmpeqb %xmm5, %xmm8, %xmm0 + LONG $0xd0d7f9c5 // vpmovmskb %xmm0, %edx + LONG $0xc674b9c5 // vpcmpeqb %xmm6, %xmm8, %xmm0 + LONG $0xf0d779c5 // vpmovmskb %xmm0, %r14d + LONG $0xc774b9c5 // vpcmpeqb %xmm7, %xmm8, %xmm0 + LONG $0xd8d779c5 // vpmovmskb %xmm0, %r11d + LONG $0xc174d9c5 // vpcmpeqb %xmm1, %xmm4, %xmm0 + LONG $0xc8d7f9c5 // vpmovmskb %xmm0, %ecx + LONG $0xc174d1c5 // vpcmpeqb %xmm1, %xmm5, %xmm0 + LONG $0xc8d779c5 // vpmovmskb %xmm0, %r9d + LONG $0xc174c9c5 // vpcmpeqb %xmm1, %xmm6, %xmm0 + LONG $0xc0d779c5 // vpmovmskb %xmm0, %r8d + LONG $0xc174c1c5 // vpcmpeqb %xmm1, %xmm7, %xmm0 + LONG $0xc0d7f9c5 // vpmovmskb %xmm0, %eax + LONG $0xc464e9c5 // vpcmpgtb %xmm4, %xmm2, %xmm0 + LONG $0xe364d9c5 // vpcmpgtb %xmm3, %xmm4, %xmm4 + LONG $0xc4dbf9c5 // vpand %xmm4, %xmm0, %xmm0 + LONG $0xd8d7f9c5 // vpmovmskb %xmm0, %ebx + LONG $0xc564e9c5 // vpcmpgtb %xmm5, %xmm2, %xmm0 + LONG $0xe364d1c5 // vpcmpgtb %xmm3, %xmm5, %xmm4 + LONG $0xc4dbf9c5 // vpand %xmm4, %xmm0, %xmm0 + LONG $0xf8d7f9c5 // vpmovmskb %xmm0, %edi + LONG $0xc664e9c5 // vpcmpgtb %xmm6, %xmm2, %xmm0 + LONG $0xe364c9c5 // vpcmpgtb %xmm3, %xmm6, %xmm4 + LONG $0xc4dbf9c5 // vpand %xmm4, %xmm0, %xmm0 + LONG $0xd0d779c5 // vpmovmskb %xmm0, %r10d + LONG $0xc764e9c5 // vpcmpgtb %xmm7, %xmm2, %xmm0 + LONG $0xe364c1c5 // vpcmpgtb %xmm3, %xmm7, %xmm4 + LONG $0xc4dbf9c5 // vpand %xmm4, %xmm0, %xmm0 + LONG $0xe0d779c5 // vpmovmskb %xmm0, %r12d + LONG $0x30e3c149 // shlq $48, %r11 + LONG $0x20e6c149 // shlq $32, %r14 + LONG $0x10e2c148 // shlq $16, %rdx + WORD $0x0949; BYTE $0xd5 // orq %rdx, %r13 + WORD $0x094d; BYTE $0xf5 // orq %r14, %r13 + WORD $0x094d; BYTE $0xdd // orq %r11, %r13 + LONG $0x30e0c148 // shlq $48, %rax + LONG $0x20e0c149 // shlq $32, %r8 LONG $0x10e1c149 // shlq $16, %r9 - WORD $0x094d; BYTE $0xd9 // orq %r11, %r9 - WORD $0x094d; BYTE $0xcc // orq %r9, %r12 - LONG $0x30e2c149 // shlq $48, %r10 - LONG $0x20e7c148 // shlq $32, %rdi - WORD $0x094c; BYTE $0xd7 // orq %r10, %rdi - LONG $0x10e1c148 // shlq $16, %rcx - WORD $0x0948; BYTE $0xf9 // orq %rdi, %rcx - LONG $0x30e0c149 // shlq $48, %r8 - LONG $0x20e0c148 // shlq $32, %rax - WORD $0x094c; BYTE $0xc0 // orq %r8, %rax - LONG $0x10e3c148 // shlq $16, %rbx - WORD $0x0948; BYTE $0xc3 // orq %rax, %rbx - WORD $0x0949; BYTE $0xcd // orq %rcx, %r13 - LONG $0x0044850f; WORD $0x0000 // jne LBB18_11, $68(%rip) - WORD $0x854d; BYTE $0xf6 // testq %r14, %r14 - LONG $0x0058850f; WORD $0x0000 // jne LBB18_13, $88(%rip) - WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d + WORD $0x094c; BYTE $0xc9 // orq %r9, %rcx + WORD $0x094c; BYTE $0xc1 // orq %r8, %rcx + LONG $0x30e4c149 // shlq $48, %r12 + LONG $0x20e2c149 // shlq $32, %r10 + LONG $0x10e7c148 // shlq $16, %rdi + WORD $0x0948; BYTE $0xfb // orq %rdi, %rbx + WORD $0x094c; BYTE $0xd3 // orq %r10, %rbx + WORD $0x0948; BYTE $0xc1 // orq %rax, %rcx + LONG $0x003c850f; WORD $0x0000 // jne LBB13_10, $60(%rip) + WORD $0x854d; BYTE $0xff // testq %r15, %r15 + LONG $0x0057850f; WORD $0x0000 // jne LBB13_12, $87(%rip) + WORD $0x3145; BYTE $0xff // xorl %r15d, %r15d + WORD $0x094c; BYTE $0xe3 // orq %r12, %rbx + WORD $0x854d; BYTE $0xed // testq %r13, %r13 + LONG $0x009d850f; WORD $0x0000 // jne LBB13_13, $157(%rip) -LBB18_8: - LONG $0xe2dae1c5 // vpminub %xmm2, %xmm3, %xmm4 - LONG $0xdc74e1c5 // vpcmpeqb %xmm4, %xmm3, %xmm3 - LONG $0xc3d7f9c5 // vpmovmskb %xmm3, %eax - WORD $0x0948; BYTE $0xc3 // orq %rax, %rbx - WORD $0x854d; BYTE $0xe4 // testq %r12, %r12 - LONG $0x008b850f; WORD $0x0000 // jne LBB18_14, $139(%rip) +LBB13_8: WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx - LONG $0x00d5850f; WORD $0x0000 // jne LBB18_20, $213(%rip) - LONG $0xc0c78349 // addq $-64, %r15 + LONG $0x00f2850f; WORD $0x0000 // jne LBB13_19, $242(%rip) LONG $0x40c68348 // addq $64, %rsi - LONG $0x3fff8349 // cmpq $63, %r15 - LONG $0xff00870f; WORD $0xffff // ja LBB18_5, $-256(%rip) - LONG $0x0000e3e9; BYTE $0x00 // jmp LBB18_22, $227(%rip) + LONG $0xb85d8b48 // movq $-72(%rbp), %rbx + LONG $0xc0c38348 // addq $-64, %rbx + LONG $0x3ffb8348 // cmpq $63, %rbx + LONG $0xfef0870f; WORD $0xffff // ja LBB13_5, $-272(%rip) + LONG $0x00010be9; BYTE $0x00 // jmp LBB13_23, $267(%rip) -LBB18_11: - LONG $0xc87d8348; BYTE $0xff // cmpq $-1, $-56(%rbp) - LONG $0x0012850f; WORD $0x0000 // jne LBB18_13, $18(%rip) - LONG $0xcdbc0f49 // bsfq %r13, %rcx - WORD $0x0148; BYTE $0xf1 // addq %rsi, %rcx - LONG $0xc0458b48 // movq $-64(%rbp), %rax - LONG $0xc84d8948 // movq %rcx, $-56(%rbp) - WORD $0x8948; BYTE $0x08 // movq %rcx, (%rax) +LBB13_10: + LONG $0xd07d8348; BYTE $0xff // cmpq $-1, $-48(%rbp) + LONG $0x0019850f; WORD $0x0000 // jne LBB13_12, $25(%rip) + WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax + LONG $0xc0452b48 // subq $-64(%rbp), %rax + LONG $0xd1bc0f48 // bsfq %rcx, %rdx + WORD $0x0148; BYTE $0xc2 // addq %rax, %rdx + LONG $0xc8458b48 // movq $-56(%rbp), %rax + LONG $0xd0558948 // movq %rdx, $-48(%rbp) + WORD $0x8948; BYTE $0x10 // movq %rdx, (%rax) -LBB18_13: - WORD $0x894c; BYTE $0xf0 // movq %r14, %rax +LBB13_12: + WORD $0x894c; BYTE $0xf8 // movq %r15, %rax WORD $0xf748; BYTE $0xd0 // notq %rax - WORD $0x214c; BYTE $0xe8 // andq %r13, %rax - LONG $0x000c8d48 // leaq (%rax,%rax), %rcx - WORD $0x094c; BYTE $0xf1 // orq %r14, %rcx - WORD $0x8948; BYTE $0xca // movq %rcx, %rdx - WORD $0xf748; BYTE $0xd2 // notq %rdx - WORD $0x214c; BYTE $0xea // andq %r13, %rdx - QUAD $0xaaaaaaaaaaaabf48; WORD $0xaaaa // movabsq $-6148914691236517206, %rdi - WORD $0x2148; BYTE $0xfa // andq %rdi, %rdx - WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d - WORD $0x0148; BYTE $0xc2 // addq %rax, %rdx - LONG $0xc6920f41 // setb %r14b - WORD $0x0148; BYTE $0xd2 // addq %rdx, %rdx + WORD $0x2148; BYTE $0xc8 // andq %rcx, %rax + LONG $0x00148d48 // leaq (%rax,%rax), %rdx + WORD $0x094c; BYTE $0xfa // orq %r15, %rdx + WORD $0x8948; BYTE $0xd7 // movq %rdx, %rdi + WORD $0xf748; BYTE $0xd7 // notq %rdi + WORD $0x2148; BYTE $0xcf // andq %rcx, %rdi + QUAD $0xaaaaaaaaaaaab948; WORD $0xaaaa // movabsq $-6148914691236517206, %rcx + WORD $0x2148; BYTE $0xcf // andq %rcx, %rdi + WORD $0x3145; BYTE $0xff // xorl %r15d, %r15d + WORD $0x0148; BYTE $0xc7 // addq %rax, %rdi + LONG $0xc7920f41 // setb %r15b + WORD $0x0148; BYTE $0xff // addq %rdi, %rdi QUAD $0x555555555555b848; WORD $0x5555 // movabsq $6148914691236517205, %rax - WORD $0x3148; BYTE $0xc2 // xorq %rax, %rdx - WORD $0x2148; BYTE $0xca // andq %rcx, %rdx - WORD $0xf748; BYTE $0xd2 // notq %rdx - WORD $0x2149; BYTE $0xd4 // andq %rdx, %r12 - LONG $0xffff5de9; BYTE $0xff // jmp LBB18_8, $-163(%rip) + WORD $0x3148; BYTE $0xc7 // xorq %rax, %rdi + WORD $0x2148; BYTE $0xd7 // andq %rdx, %rdi + WORD $0xf748; BYTE $0xd7 // notq %rdi + WORD $0x2149; BYTE $0xfd // andq %rdi, %r13 + WORD $0x094c; BYTE $0xe3 // orq %r12, %rbx + WORD $0x854d; BYTE $0xed // testq %r13, %r13 + LONG $0xff63840f; WORD $0xffff // je LBB13_8, $-157(%rip) -LBB18_14: - LONG $0xc4bc0f49 // bsfq %r12, %rax +LBB13_13: + LONG $0xc5bc0f49 // bsfq %r13, %rax WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx - LONG $0x0022840f; WORD $0x0000 // je LBB18_18, $34(%rip) + LONG $0x0029840f; WORD $0x0000 // je LBB13_17, $41(%rip) LONG $0xcbbc0f48 // bsfq %rbx, %rcx + LONG $0xc8558b48 // movq $-56(%rbp), %rdx + LONG $0xc0752b48 // subq $-64(%rbp), %rsi WORD $0x3948; BYTE $0xc1 // cmpq %rax, %rcx - LONG $0x0023820f; WORD $0x0000 // jb LBB18_19, $35(%rip) + LONG $0x002a820f; WORD $0x0000 // jb LBB13_18, $42(%rip) -LBB18_16: - WORD $0x0148; BYTE $0xf0 // addq %rsi, %rax - WORD $0xff48; BYTE $0xc0 // incq %rax +LBB13_15: + LONG $0x06448d48; BYTE $0x01 // leaq $1(%rsi,%rax), %rax -LBB18_17: - LONG $0x18c48348 // addq $24, %rsp +LBB13_16: + LONG $0x20c48348 // addq $32, %rsp BYTE $0x5b // popq %rbx WORD $0x5c41 // popq %r12 WORD $0x5d41 // popq %r13 @@ -5027,230 +4273,241 @@ LBB18_17: BYTE $0x5d // popq %rbp BYTE $0xc3 // retq -LBB18_18: +LBB13_17: LONG $0x000040b9; BYTE $0x00 // movl $64, %ecx + LONG $0xc8558b48 // movq $-56(%rbp), %rdx + LONG $0xc0752b48 // subq $-64(%rbp), %rsi WORD $0x3948; BYTE $0xc1 // cmpq %rax, %rcx - LONG $0xffdd830f; WORD $0xffff // jae LBB18_16, $-35(%rip) + LONG $0xffd6830f; WORD $0xffff // jae LBB13_15, $-42(%rip) -LBB18_19: +LBB13_18: WORD $0x0148; BYTE $0xf1 // addq %rsi, %rcx - LONG $0xc0458b48 // movq $-64(%rbp), %rax - WORD $0x8948; BYTE $0x08 // movq %rcx, (%rax) + WORD $0x8948; BYTE $0x0a // movq %rcx, (%rdx) LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq $-2, %rax - LONG $0xffffcde9; BYTE $0xff // jmp LBB18_17, $-51(%rip) + LONG $0xffffc9e9; BYTE $0xff // jmp LBB13_16, $-55(%rip) -LBB18_20: +LBB13_19: LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq $-2, %rax - LONG $0xc87d8348; BYTE $0xff // cmpq $-1, $-56(%rbp) - LONG $0xffbb850f; WORD $0xffff // jne LBB18_17, $-69(%rip) + LONG $0xd07d8348; BYTE $0xff // cmpq $-1, $-48(%rbp) + LONG $0xffb7850f; WORD $0xffff // jne LBB13_16, $-73(%rip) LONG $0xcbbc0f48 // bsfq %rbx, %rcx - WORD $0x0148; BYTE $0xf1 // addq %rsi, %rcx - LONG $0xc0558b48 // movq $-64(%rbp), %rdx - WORD $0x8948; BYTE $0x0a // movq %rcx, (%rdx) - LONG $0xffffa8e9; BYTE $0xff // jmp LBB18_17, $-88(%rip) + LONG $0xc0752b48 // subq $-64(%rbp), %rsi + WORD $0x0148; BYTE $0xce // addq %rcx, %rsi + LONG $0xc84d8b48 // movq $-56(%rbp), %rcx + WORD $0x8948; BYTE $0x31 // movq %rsi, (%rcx) + LONG $0xffffa0e9; BYTE $0xff // jmp LBB13_16, $-96(%rip) -LBB18_22: - LONG $0xd0750348 // addq $-48(%rbp), %rsi - LONG $0x20ff8349 // cmpq $32, %r15 - LONG $0x00d7820f; WORD $0x0000 // jb LBB18_35, $215(%rip) +LBB13_22: + QUAD $0xffffffffd045c748 // movq $-1, $-48(%rbp) + WORD $0x3145; BYTE $0xff // xorl %r15d, %r15d -LBB18_23: +LBB13_23: + LONG $0x20fb8348 // cmpq $32, %rbx + LONG $0x00e1820f; WORD $0x0000 // jb LBB13_36, $225(%rip) LONG $0x066ffac5 // vmovdqu (%rsi), %xmm0 LONG $0x4e6ffac5; BYTE $0x10 // vmovdqu $16(%rsi), %xmm1 - QUAD $0xfffffd59156ff9c5 // vmovdqa $-679(%rip), %xmm2 /* LCPI18_0(%rip) */ + QUAD $0xfffffd15156ff9c5 // vmovdqa $-747(%rip), %xmm2 /* LCPI13_0(%rip) */ LONG $0xda74f9c5 // vpcmpeqb %xmm2, %xmm0, %xmm3 - LONG $0xc3d7f9c5 // vpmovmskb %xmm3, %eax + LONG $0xdbd779c5 // vpmovmskb %xmm3, %r11d LONG $0xd274f1c5 // vpcmpeqb %xmm2, %xmm1, %xmm2 - LONG $0xcad7f9c5 // vpmovmskb %xmm2, %ecx - QUAD $0xfffffd51156ff9c5 // vmovdqa $-687(%rip), %xmm2 /* LCPI18_1(%rip) */ + LONG $0xd2d7f9c5 // vpmovmskb %xmm2, %edx + QUAD $0xfffffd0d156ff9c5 // vmovdqa $-755(%rip), %xmm2 /* LCPI13_1(%rip) */ LONG $0xda74f9c5 // vpcmpeqb %xmm2, %xmm0, %xmm3 LONG $0xd3d779c5 // vpmovmskb %xmm3, %r10d LONG $0xd274f1c5 // vpcmpeqb %xmm2, %xmm1, %xmm2 - LONG $0xd2d7f9c5 // vpmovmskb %xmm2, %edx - QUAD $0xfffffd49156ff9c5 // vmovdqa $-695(%rip), %xmm2 /* LCPI18_2(%rip) */ - LONG $0xdadaf9c5 // vpminub %xmm2, %xmm0, %xmm3 - LONG $0xc374f9c5 // vpcmpeqb %xmm3, %xmm0, %xmm0 - LONG $0xc8d779c5 // vpmovmskb %xmm0, %r9d - LONG $0xc2daf1c5 // vpminub %xmm2, %xmm1, %xmm0 - LONG $0xc074f1c5 // vpcmpeqb %xmm0, %xmm1, %xmm0 - LONG $0xd8d7f9c5 // vpmovmskb %xmm0, %ebx - LONG $0x10e1c148 // shlq $16, %rcx - WORD $0x0948; BYTE $0xc8 // orq %rcx, %rax + LONG $0xc2d7f9c5 // vpmovmskb %xmm2, %eax + QUAD $0xfffffd05156ff9c5 // vmovdqa $-763(%rip), %xmm2 /* LCPI13_2(%rip) */ + LONG $0xd864e9c5 // vpcmpgtb %xmm0, %xmm2, %xmm3 + LONG $0xe476d9c5 // vpcmpeqd %xmm4, %xmm4, %xmm4 + LONG $0xc464f9c5 // vpcmpgtb %xmm4, %xmm0, %xmm0 + LONG $0xc0dbe1c5 // vpand %xmm0, %xmm3, %xmm0 + LONG $0xc0d779c5 // vpmovmskb %xmm0, %r8d + LONG $0xc164e9c5 // vpcmpgtb %xmm1, %xmm2, %xmm0 + LONG $0xcc64f1c5 // vpcmpgtb %xmm4, %xmm1, %xmm1 + LONG $0xc1dbf9c5 // vpand %xmm1, %xmm0, %xmm0 + LONG $0xf8d7f9c5 // vpmovmskb %xmm0, %edi LONG $0x10e2c148 // shlq $16, %rdx - LONG $0x10e3c148 // shlq $16, %rbx - WORD $0x0949; BYTE $0xd2 // orq %rdx, %r10 - LONG $0x011f850f; WORD $0x0000 // jne LBB18_49, $287(%rip) - WORD $0x854d; BYTE $0xf6 // testq %r14, %r14 - LONG $0x013a850f; WORD $0x0000 // jne LBB18_51, $314(%rip) - WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d + WORD $0x0949; BYTE $0xd3 // orq %rdx, %r11 + LONG $0x10e0c148 // shlq $16, %rax + LONG $0x10e7c148 // shlq $16, %rdi + WORD $0x0949; BYTE $0xc2 // orq %rax, %r10 + LONG $0x0111850f; WORD $0x0000 // jne LBB13_48, $273(%rip) + WORD $0x854d; BYTE $0xff // testq %r15, %r15 + LONG $0x012c850f; WORD $0x0000 // jne LBB13_50, $300(%rip) + WORD $0x3145; BYTE $0xff // xorl %r15d, %r15d -LBB18_26: - WORD $0x094c; BYTE $0xcb // orq %r9, %rbx - LONG $0x000040b9; BYTE $0x00 // movl $64, %ecx +LBB13_27: + WORD $0x094c; BYTE $0xc7 // orq %r8, %rdi + LONG $0x000040b8; BYTE $0x00 // movl $64, %eax LONG $0x000040ba; BYTE $0x00 // movl $64, %edx - WORD $0x8548; BYTE $0xc0 // testq %rax, %rax - LONG $0x0004840f; WORD $0x0000 // je LBB18_28, $4(%rip) - LONG $0xd0bc0f48 // bsfq %rax, %rdx + WORD $0x854d; BYTE $0xdb // testq %r11, %r11 + LONG $0x0004840f; WORD $0x0000 // je LBB13_29, $4(%rip) + LONG $0xd3bc0f49 // bsfq %r11, %rdx -LBB18_28: - WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx - LONG $0x0004840f; WORD $0x0000 // je LBB18_30, $4(%rip) - LONG $0xcbbc0f48 // bsfq %rbx, %rcx +LBB13_29: + WORD $0x8548; BYTE $0xff // testq %rdi, %rdi + LONG $0x0004840f; WORD $0x0000 // je LBB13_31, $4(%rip) + LONG $0xc7bc0f48 // bsfq %rdi, %rax -LBB18_30: - WORD $0x8548; BYTE $0xc0 // testq %rax, %rax - LONG $0x0019840f; WORD $0x0000 // je LBB18_33, $25(%rip) - WORD $0x3948; BYTE $0xd1 // cmpq %rdx, %rcx - LONG $0x0135820f; WORD $0x0000 // jb LBB18_52, $309(%rip) - LONG $0xd0752b48 // subq $-48(%rbp), %rsi - LONG $0x16048d48 // leaq (%rsi,%rdx), %rax - WORD $0xff48; BYTE $0xc0 // incq %rax - LONG $0xfffed4e9; BYTE $0xff // jmp LBB18_17, $-300(%rip) +LBB13_31: + WORD $0x854d; BYTE $0xdb // testq %r11, %r11 + LONG $0x0017840f; WORD $0x0000 // je LBB13_34, $23(%rip) + LONG $0xc0752b48 // subq $-64(%rbp), %rsi + WORD $0x3948; BYTE $0xd0 // cmpq %rdx, %rax + LONG $0x0124820f; WORD $0x0000 // jb LBB13_51, $292(%rip) + LONG $0x16448d48; BYTE $0x01 // leaq $1(%rsi,%rdx), %rax + LONG $0xfffebbe9; BYTE $0xff // jmp LBB13_16, $-325(%rip) -LBB18_33: - WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx - LONG $0x011c850f; WORD $0x0000 // jne LBB18_52, $284(%rip) +LBB13_34: + WORD $0x8548; BYTE $0xff // testq %rdi, %rdi + LONG $0x0127850f; WORD $0x0000 // jne LBB13_52, $295(%rip) LONG $0x20c68348 // addq $32, %rsi - LONG $0xe0c78349 // addq $-32, %r15 + LONG $0xe0c38348 // addq $-32, %rbx -LBB18_35: - WORD $0x854d; BYTE $0xf6 // testq %r14, %r14 - LONG $0x0125850f; WORD $0x0000 // jne LBB18_54, $293(%rip) - LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax +LBB13_36: WORD $0x854d; BYTE $0xff // testq %r15, %r15 - LONG $0xfeaa840f; WORD $0xffff // je LBB18_17, $-342(%rip) + LONG $0x0122850f; WORD $0x0000 // jne LBB13_53, $290(%rip) + LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax + WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx + LONG $0xfe91840f; WORD $0xffff // je LBB13_16, $-367(%rip) -LBB18_37: - LONG $0xc07d8b48 // movq $-64(%rbp), %rdi +LBB13_38: + LONG $0xc87d8b48 // movq $-56(%rbp), %rdi -LBB18_38: +LBB13_39: WORD $0xb60f; BYTE $0x0e // movzbl (%rsi), %ecx - WORD $0xf983; BYTE $0x22 // cmpl $34, %ecx - LONG $0x0063840f; WORD $0x0000 // je LBB18_46, $99(%rip) - WORD $0xf983; BYTE $0x5c // cmpl $92, %ecx - LONG $0x0026840f; WORD $0x0000 // je LBB18_43, $38(%rip) + WORD $0xf980; BYTE $0x22 // cmpb $34, %cl + LONG $0x0075840f; WORD $0x0000 // je LBB13_47, $117(%rip) + WORD $0xf980; BYTE $0x5c // cmpb $92, %cl + LONG $0x0026840f; WORD $0x0000 // je LBB13_43, $38(%rip) WORD $0xf980; BYTE $0x1f // cmpb $31, %cl - LONG $0x0143860f; WORD $0x0000 // jbe LBB18_58, $323(%rip) + LONG $0x0146860f; WORD $0x0000 // jbe LBB13_57, $326(%rip) LONG $0xffc1c748; WORD $0xffff; BYTE $0xff // movq $-1, %rcx LONG $0x000001ba; BYTE $0x00 // movl $1, %edx + WORD $0x0148; BYTE $0xd6 // addq %rdx, %rsi + WORD $0x0148; BYTE $0xcb // addq %rcx, %rbx + LONG $0xffca850f; WORD $0xffff // jne LBB13_39, $-54(%rip) + LONG $0xfffe52e9; BYTE $0xff // jmp LBB13_16, $-430(%rip) -LBB18_42: - WORD $0x0148; BYTE $0xd6 // addq %rdx, %rsi - WORD $0x0149; BYTE $0xcf // addq %rcx, %r15 - LONG $0xffca850f; WORD $0xffff // jne LBB18_38, $-54(%rip) - LONG $0xfffe6be9; BYTE $0xff // jmp LBB18_17, $-405(%rip) - -LBB18_43: - LONG $0x01ff8349 // cmpq $1, %r15 - LONG $0xfe61840f; WORD $0xffff // je LBB18_17, $-415(%rip) +LBB13_43: + LONG $0x01fb8348 // cmpq $1, %rbx + LONG $0xfe48840f; WORD $0xffff // je LBB13_16, $-440(%rip) + WORD $0x8949; BYTE $0xd8 // movq %rbx, %r8 LONG $0xfec1c748; WORD $0xffff; BYTE $0xff // movq $-2, %rcx LONG $0x000002ba; BYTE $0x00 // movl $2, %edx - LONG $0xc87d8348; BYTE $0xff // cmpq $-1, $-56(%rbp) - LONG $0xffce850f; WORD $0xffff // jne LBB18_42, $-50(%rip) + LONG $0xd07d8348; BYTE $0xff // cmpq $-1, $-48(%rbp) + LONG $0x000e850f; WORD $0x0000 // jne LBB13_46, $14(%rip) WORD $0x8948; BYTE $0xf3 // movq %rsi, %rbx - LONG $0xd05d2b48 // subq $-48(%rbp), %rbx - LONG $0xc85d8948 // movq %rbx, $-56(%rbp) + LONG $0xc05d2b48 // subq $-64(%rbp), %rbx + LONG $0xd05d8948 // movq %rbx, $-48(%rbp) WORD $0x8948; BYTE $0x1f // movq %rbx, (%rdi) - LONG $0xffffbbe9; BYTE $0xff // jmp LBB18_42, $-69(%rip) -LBB18_46: - LONG $0xd0752b48 // subq $-48(%rbp), %rsi +LBB13_46: + WORD $0x894c; BYTE $0xc3 // movq %r8, %rbx + WORD $0x0148; BYTE $0xd6 // addq %rdx, %rsi + WORD $0x0148; BYTE $0xcb // addq %rcx, %rbx + LONG $0xff84850f; WORD $0xffff // jne LBB13_39, $-124(%rip) + LONG $0xfffe0ce9; BYTE $0xff // jmp LBB13_16, $-500(%rip) + +LBB13_47: + LONG $0xc0752b48 // subq $-64(%rbp), %rsi WORD $0xff48; BYTE $0xc6 // incq %rsi WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax - LONG $0xfffe28e9; BYTE $0xff // jmp LBB18_17, $-472(%rip) + LONG $0xfffdfde9; BYTE $0xff // jmp LBB13_16, $-515(%rip) -LBB18_48: - LONG $0xd0750348 // addq $-48(%rbp), %rsi - QUAD $0xffffffffc845c748 // movq $-1, $-56(%rbp) - WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d - LONG $0x20ff8349 // cmpq $32, %r15 - LONG $0xfe75830f; WORD $0xffff // jae LBB18_23, $-395(%rip) - LONG $0xffff47e9; BYTE $0xff // jmp LBB18_35, $-185(%rip) - -LBB18_49: - LONG $0xc87d8348; BYTE $0xff // cmpq $-1, $-56(%rbp) - LONG $0x0019850f; WORD $0x0000 // jne LBB18_51, $25(%rip) - WORD $0x8948; BYTE $0xf1 // movq %rsi, %rcx - LONG $0xd04d2b48 // subq $-48(%rbp), %rcx +LBB13_48: + LONG $0xd07d8348; BYTE $0xff // cmpq $-1, $-48(%rbp) + LONG $0x0019850f; WORD $0x0000 // jne LBB13_50, $25(%rip) + WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax + LONG $0xc0452b48 // subq $-64(%rbp), %rax LONG $0xd2bc0f49 // bsfq %r10, %rdx - WORD $0x0148; BYTE $0xca // addq %rcx, %rdx - LONG $0xc04d8b48 // movq $-64(%rbp), %rcx - LONG $0xc8558948 // movq %rdx, $-56(%rbp) - WORD $0x8948; BYTE $0x11 // movq %rdx, (%rcx) + WORD $0x0148; BYTE $0xc2 // addq %rax, %rdx + LONG $0xc8458b48 // movq $-56(%rbp), %rax + LONG $0xd0558948 // movq %rdx, $-48(%rbp) + WORD $0x8948; BYTE $0x10 // movq %rdx, (%rax) -LBB18_51: - WORD $0x8944; BYTE $0xf1 // movl %r14d, %ecx - WORD $0xd1f7 // notl %ecx - WORD $0x2144; BYTE $0xd1 // andl %r10d, %ecx - WORD $0x148d; BYTE $0x09 // leal (%rcx,%rcx), %edx - LONG $0x4e048d45 // leal (%r14,%rcx,2), %r8d +LBB13_50: + WORD $0x8944; BYTE $0xf8 // movl %r15d, %eax + WORD $0xd0f7 // notl %eax + WORD $0x2144; BYTE $0xd0 // andl %r10d, %eax + LONG $0x470c8d45 // leal (%r15,%rax,2), %r9d + WORD $0x148d; BYTE $0x00 // leal (%rax,%rax), %edx WORD $0xd2f7 // notl %edx WORD $0x2144; BYTE $0xd2 // andl %r10d, %edx LONG $0xaaaae281; WORD $0xaaaa // andl $-1431655766, %edx - WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d - WORD $0xca01 // addl %ecx, %edx - LONG $0xc6920f41 // setb %r14b + WORD $0x3145; BYTE $0xff // xorl %r15d, %r15d + WORD $0xc201 // addl %eax, %edx + LONG $0xc7920f41 // setb %r15b WORD $0xd201 // addl %edx, %edx LONG $0x5555f281; WORD $0x5555 // xorl $1431655765, %edx - WORD $0x2144; BYTE $0xc2 // andl %r8d, %edx + WORD $0x2144; BYTE $0xca // andl %r9d, %edx WORD $0xd2f7 // notl %edx - WORD $0xd021 // andl %edx, %eax - LONG $0xfffe92e9; BYTE $0xff // jmp LBB18_26, $-366(%rip) + WORD $0x2141; BYTE $0xd3 // andl %edx, %r11d + LONG $0xfffe9fe9; BYTE $0xff // jmp LBB13_27, $-353(%rip) -LBB18_52: - LONG $0xd0752b48 // subq $-48(%rbp), %rsi - WORD $0x0148; BYTE $0xce // addq %rcx, %rsi - -LBB18_53: - LONG $0xc0458b48 // movq $-64(%rbp), %rax - WORD $0x8948; BYTE $0x30 // movq %rsi, (%rax) +LBB13_51: + WORD $0x0148; BYTE $0xf0 // addq %rsi, %rax + LONG $0xc84d8b48 // movq $-56(%rbp), %rcx + WORD $0x8948; BYTE $0x01 // movq %rax, (%rcx) LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq $-2, %rax - LONG $0xfffd95e9; BYTE $0xff // jmp LBB18_17, $-619(%rip) + LONG $0xfffd8be9; BYTE $0xff // jmp LBB13_16, $-629(%rip) -LBB18_54: - WORD $0x854d; BYTE $0xff // testq %r15, %r15 - LONG $0x003b840f; WORD $0x0000 // je LBB18_47, $59(%rip) - LONG $0xc87d8348; BYTE $0xff // cmpq $-1, $-56(%rbp) - LONG $0x0015850f; WORD $0x0000 // jne LBB18_57, $21(%rip) - LONG $0xd04d8b48 // movq $-48(%rbp), %rcx +LBB13_52: + LONG $0xc0752b48 // subq $-64(%rbp), %rsi + WORD $0x0148; BYTE $0xc6 // addq %rax, %rsi + LONG $0x00005ae9; BYTE $0x00 // jmp LBB13_58, $90(%rip) + +LBB13_53: + WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx + LONG $0x0041840f; WORD $0x0000 // je LBB13_21, $65(%rip) + WORD $0x8948; BYTE $0xda // movq %rbx, %rdx + LONG $0xd07d8348; BYTE $0xff // cmpq $-1, $-48(%rbp) + LONG $0x0015850f; WORD $0x0000 // jne LBB13_56, $21(%rip) + LONG $0xc04d8b48 // movq $-64(%rbp), %rcx WORD $0xf748; BYTE $0xd1 // notq %rcx WORD $0x0148; BYTE $0xf1 // addq %rsi, %rcx - LONG $0xc0458b48 // movq $-64(%rbp), %rax - LONG $0xc84d8948 // movq %rcx, $-56(%rbp) + LONG $0xc8458b48 // movq $-56(%rbp), %rax + LONG $0xd04d8948 // movq %rcx, $-48(%rbp) WORD $0x8948; BYTE $0x08 // movq %rcx, (%rax) -LBB18_57: +LBB13_56: WORD $0xff48; BYTE $0xc6 // incq %rsi - WORD $0xff49; BYTE $0xcf // decq %r15 + WORD $0x8948; BYTE $0xd3 // movq %rdx, %rbx + WORD $0xff48; BYTE $0xcb // decq %rbx LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax - WORD $0x854d; BYTE $0xff // testq %r15, %r15 - LONG $0xfeac850f; WORD $0xffff // jne LBB18_37, $-340(%rip) - LONG $0xfffd51e9; BYTE $0xff // jmp LBB18_17, $-687(%rip) + WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx + LONG $0xfea9850f; WORD $0xffff // jne LBB13_38, $-343(%rip) + LONG $0xfffd35e9; BYTE $0xff // jmp LBB13_16, $-715(%rip) -LBB18_47: +LBB13_21: LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax - LONG $0xfffd45e9; BYTE $0xff // jmp LBB18_17, $-699(%rip) + LONG $0xfffd29e9; BYTE $0xff // jmp LBB13_16, $-727(%rip) -LBB18_58: - LONG $0xd0752b48 // subq $-48(%rbp), %rsi - LONG $0xffff94e9; BYTE $0xff // jmp LBB18_53, $-108(%rip) - QUAD $0x0000000000000000; LONG $0x00000000 // .p2align 4, 0x00 +LBB13_57: + LONG $0xc0752b48 // subq $-64(%rbp), %rsi -LCPI19_0: +LBB13_58: + LONG $0xc8458b48 // movq $-56(%rbp), %rax + WORD $0x8948; BYTE $0x30 // movq %rsi, (%rax) + LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq $-2, %rax + LONG $0xfffd12e9; BYTE $0xff // jmp LBB13_16, $-750(%rip) + QUAD $0x0000000000000000; LONG $0x00000000; BYTE $0x00 // .p2align 4, 0x00 + +LCPI14_0: LONG $0x43300000 // .long 1127219200 LONG $0x45300000 // .long 1160773632 LONG $0x00000000 // .long 0 LONG $0x00000000 // .long 0 -LCPI19_1: +LCPI14_1: QUAD $0x4330000000000000 // .quad 0x4330000000000000 QUAD $0x4530000000000000 // .quad 0x4530000000000000 // .p2align 3, 0x00 -LCPI19_2: +LCPI14_2: QUAD $0x430c6bf526340000 // .quad 0x430c6bf526340000 -LCPI19_3: +LCPI14_3: QUAD $0xc30c6bf526340000 // .quad 0xc30c6bf526340000 // .p2align 4, 0x90 @@ -5263,12 +4520,12 @@ _vnumber: WORD $0x5441 // pushq %r12 BYTE $0x53 // pushq %rbx LONG $0x38ec8348 // subq $56, %rsp - WORD $0x8948; BYTE $0xd3 // movq %rdx, %rbx - WORD $0x8949; BYTE $0xf6 // movq %rsi, %r14 + WORD $0x8949; BYTE $0xd6 // movq %rdx, %r14 + QUAD $0x00000000c845c748 // movq $0, $-56(%rbp) WORD $0x8b48; BYTE $0x06 // movq (%rsi), %rax WORD $0x8b4c; BYTE $0x3f // movq (%rdi), %r15 LONG $0x086f8b4c // movq $8(%rdi), %r13 - LONG $0x20528b4c // movq $32(%rdx), %r10 + LONG $0x205a8b48 // movq $32(%rdx), %rbx LONG $0x285a8b4c // movq $40(%rdx), %r11 LONG $0x0902c748; WORD $0x0000; BYTE $0x00 // movq $9, (%rdx) LONG $0xc057f9c5 // vxorpd %xmm0, %xmm0, %xmm0 @@ -5276,436 +4533,465 @@ _vnumber: WORD $0x8b48; BYTE $0x0e // movq (%rsi), %rcx LONG $0x184a8948 // movq %rcx, $24(%rdx) WORD $0x394c; BYTE $0xe8 // cmpq %r13, %rax - LONG $0x02c9830f; WORD $0x0000 // jae LBB19_51, $713(%rip) - LONG $0x0cb60f41; BYTE $0x07 // movzbl (%r15,%rax), %ecx - LONG $0x000001bf; BYTE $0x00 // movl $1, %edi - WORD $0xf980; BYTE $0x2d // cmpb $45, %cl - LONG $0x0016850f; WORD $0x0000 // jne LBB19_4, $22(%rip) + LONG $0x0045830f; WORD $0x0000 // jae LBB14_6, $69(%rip) + LONG $0x073c8a41 // movb (%r15,%rax), %dil + LONG $0x0001ba41; WORD $0x0000 // movl $1, %r10d + LONG $0x2dff8040 // cmpb $45, %dil + LONG $0x0016850f; WORD $0x0000 // jne LBB14_4, $22(%rip) WORD $0xff48; BYTE $0xc0 // incq %rax WORD $0x394c; BYTE $0xe8 // cmpq %r13, %rax - LONG $0x02aa830f; WORD $0x0000 // jae LBB19_51, $682(%rip) - LONG $0x0cb60f41; BYTE $0x07 // movzbl (%r15,%rax), %ecx - LONG $0xffffffbf; BYTE $0xff // movl $-1, %edi + LONG $0x0025830f; WORD $0x0000 // jae LBB14_6, $37(%rip) + LONG $0x073c8a41 // movb (%r15,%rax), %dil + LONG $0xffffba41; WORD $0xffff // movl $-1, %r10d + +LBB14_4: + WORD $0x4f8d; BYTE $0xd0 // leal $-48(%rdi), %ecx + WORD $0xf980; BYTE $0x0a // cmpb $10, %cl + LONG $0x0028820f; WORD $0x0000 // jb LBB14_9, $40(%rip) + WORD $0x8948; BYTE $0x06 // movq %rax, (%rsi) + LONG $0xfe06c749; WORD $0xffff; BYTE $0xff // movq $-2, (%r14) + LONG $0x00000ae9; BYTE $0x00 // jmp LBB14_8, $10(%rip) -LBB19_4: - WORD $0x518d; BYTE $0xc6 // leal $-58(%rcx), %edx - WORD $0xfa80; BYTE $0xf5 // cmpb $-11, %dl - LONG $0x000f870f; WORD $0x0000 // ja LBB19_6, $15(%rip) +LBB14_6: + WORD $0x894c; BYTE $0x2e // movq %r13, (%rsi) -LBB19_5: - WORD $0x8949; BYTE $0x06 // movq %rax, (%r14) - LONG $0xfe03c748; WORD $0xffff; BYTE $0xff // movq $-2, (%rbx) - LONG $0x00028fe9; BYTE $0x00 // jmp LBB19_52, $655(%rip) +LBB14_7: + LONG $0xff06c749; WORD $0xffff; BYTE $0xff // movq $-1, (%r14) -LBB19_6: - WORD $0xf980; BYTE $0x30 // cmpb $48, %cl - LONG $0x0032850f; WORD $0x0000 // jne LBB19_10, $50(%rip) - LONG $0x01488d48 // leaq $1(%rax), %rcx +LBB14_8: + LONG $0x38c48348 // addq $56, %rsp + BYTE $0x5b // popq %rbx + WORD $0x5c41 // popq %r12 + WORD $0x5d41 // popq %r13 + WORD $0x5e41 // popq %r14 + WORD $0x5f41 // popq %r15 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB14_9: + LONG $0x30ff8040 // cmpb $48, %dil + LONG $0x0035850f; WORD $0x0000 // jne LBB14_13, $53(%rip) + LONG $0x01488d4c // leaq $1(%rax), %r9 WORD $0x394c; BYTE $0xe8 // cmpq %r13, %rax - LONG $0x00a6830f; WORD $0x0000 // jae LBB19_18, $166(%rip) - LONG $0x14b60f41; BYTE $0x0f // movzbl (%r15,%rcx), %edx - WORD $0xc283; BYTE $0xd2 // addl $-46, %edx - WORD $0xfa83; BYTE $0x37 // cmpl $55, %edx - LONG $0x0095870f; WORD $0x0000 // ja LBB19_18, $149(%rip) - QUAD $0x000000800001be48; WORD $0x0080 // movabsq $36028797027352577, %rsi - LONG $0xd6a30f48 // btq %rdx, %rsi - LONG $0x0081830f; WORD $0x0000 // jae LBB19_18, $129(%rip) - -LBB19_10: - WORD $0x7d89; BYTE $0xd4 // movl %edi, $-44(%rbp) - WORD $0x01b1 // movb $1, %cl - WORD $0x4d89; BYTE $0xc8 // movl %ecx, $-56(%rbp) + LONG $0x00bf830f; WORD $0x0000 // jae LBB14_22, $191(%rip) + LONG $0x0f148a43 // movb (%r15,%r9), %dl + WORD $0xc280; BYTE $0xd2 // addb $-46, %dl + WORD $0xfa80; BYTE $0x37 // cmpb $55, %dl + LONG $0x00af870f; WORD $0x0000 // ja LBB14_22, $175(%rip) + LONG $0xc2b60f44 // movzbl %dl, %r8d + QUAD $0x000000800001ba48; WORD $0x0080 // movabsq $36028797027352577, %rdx + LONG $0xc2a30f4c // btq %r8, %rdx + LONG $0x0097830f; WORD $0x0000 // jae LBB14_22, $151(%rip) + +LBB14_13: WORD $0x394c; BYTE $0xe8 // cmpq %r13, %rax - LONG $0x0063830f; WORD $0x0000 // jae LBB19_17, $99(%rip) - WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d - LONG $0xffd0b941; WORD $0xffff // movl $4294967248, %r9d - WORD $0x3145; BYTE $0xc0 // xorl %r8d, %r8d + LONG $0xa05d8948 // movq %rbx, $-96(%rbp) + LONG $0xc0558944 // movl %r10d, $-64(%rbp) + LONG $0xd0758948 // movq %rsi, $-48(%rbp) + LONG $0x0075830f; WORD $0x0000 // jae LBB14_21, $117(%rip) + WORD $0xf980; BYTE $0x09 // cmpb $9, %cl + LONG $0x0081870f; WORD $0x0000 // ja LBB14_23, $129(%rip) + LONG $0xffd0b841; WORD $0xffff // movl $4294967248, %r8d + LONG $0xff4d8d4d // leaq $-1(%r13), %r9 WORD $0xc931 // xorl %ecx, %ecx - LONG $0x000012e9; BYTE $0x00 // jmp LBB19_13, $18(%rip) - LONG $0x90909090 // .p2align 4, 0x90 + WORD $0x3145; BYTE $0xd2 // xorl %r10d, %r10d + WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d + LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 -LBB19_12: - WORD $0xc1ff // incl %ecx - WORD $0xff48; BYTE $0xc0 // incq %rax - WORD $0x3949; BYTE $0xc5 // cmpq %rax, %r13 - LONG $0x0036840f; WORD $0x0000 // je LBB19_16, $54(%rip) +LBB14_16: + LONG $0x12fa8341 // cmpl $18, %r10d + LONG $0x00268f0f; WORD $0x0000 // jg LBB14_18, $38(%rip) + LONG $0xa4148d4b // leaq (%r12,%r12,4), %rdx + LONG $0xffbe0f40 // movsbl %dil, %edi + WORD $0x0144; BYTE $0xc7 // addl %r8d, %edi + LONG $0x57248d4c // leaq (%rdi,%rdx,2), %r12 + WORD $0xff41; BYTE $0xc2 // incl %r10d + LONG $0x000011e9; BYTE $0x00 // jmp LBB14_19, $17(%rip) + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 -LBB19_13: - LONG $0x14be0f49; BYTE $0x07 // movsbq (%r15,%rax), %rdx - WORD $0x7a8d; BYTE $0xd0 // leal $-48(%rdx), %edi - LONG $0x09ff8040 // cmpb $9, %dil - LONG $0x0041870f; WORD $0x0000 // ja LBB19_19, $65(%rip) - LONG $0x12f88341 // cmpl $18, %r8d - LONG $0xffd68f0f; WORD $0xffff // jg LBB19_12, $-42(%rip) - LONG $0xa43c8d4b // leaq (%r12,%r12,4), %rdi - WORD $0x0144; BYTE $0xca // addl %r9d, %edx - LONG $0x7a248d4c // leaq (%rdx,%rdi,2), %r12 - WORD $0xff41; BYTE $0xc0 // incl %r8d - WORD $0xff48; BYTE $0xc0 // incq %rax - WORD $0x3949; BYTE $0xc5 // cmpq %rax, %r13 - LONG $0xffca850f; WORD $0xffff // jne LBB19_13, $-54(%rip) +LBB14_18: + WORD $0xc1ff // incl %ecx -LBB19_16: - WORD $0x894c; BYTE $0xe8 // movq %r13, %rax - LONG $0x00005be9; BYTE $0x00 // jmp LBB19_24, $91(%rip) +LBB14_19: + WORD $0x3949; BYTE $0xc1 // cmpq %rax, %r9 + LONG $0x0079840f; WORD $0x0000 // je LBB14_28, $121(%rip) + LONG $0x7cb60f41; WORD $0x0107 // movzbl $1(%r15,%rax), %edi + WORD $0xff48; BYTE $0xc0 // incq %rax + WORD $0x578d; BYTE $0xd0 // leal $-48(%rdi), %edx + WORD $0xfa80; BYTE $0x0a // cmpb $10, %dl + LONG $0xffb0820f; WORD $0xffff // jb LBB14_16, $-80(%rip) + LONG $0x00001de9; BYTE $0x00 // jmp LBB14_24, $29(%rip) -LBB19_17: +LBB14_21: WORD $0xc931 // xorl %ecx, %ecx - WORD $0x3145; BYTE $0xc0 // xorl %r8d, %r8d + WORD $0x3145; BYTE $0xd2 // xorl %r10d, %r10d WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d - LONG $0x00004ee9; BYTE $0x00 // jmp LBB19_24, $78(%rip) + LONG $0x000055e9; BYTE $0x00 // jmp LBB14_29, $85(%rip) -LBB19_18: - WORD $0x8949; BYTE $0x0e // movq %rcx, (%r14) - LONG $0x0001cbe9; BYTE $0x00 // jmp LBB19_52, $459(%rip) - -LBB19_19: - WORD $0xfa80; BYTE $0x2e // cmpb $46, %dl - LONG $0x003d850f; WORD $0x0000 // jne LBB19_24, $61(%rip) - LONG $0x01508d48 // leaq $1(%rax), %rdx - LONG $0x0803c748; WORD $0x0000; BYTE $0x00 // movq $8, (%rbx) - WORD $0x394c; BYTE $0xea // cmpq %r13, %rdx - LONG $0x01a4830f; WORD $0x0000 // jae LBB19_51, $420(%rip) - LONG $0x44b60f41; WORD $0x0107 // movzbl $1(%r15,%rax), %eax - WORD $0xc604 // addb $-58, %al - WORD $0xf53c // cmpb $-11, %al - LONG $0x000f870f; WORD $0x0000 // ja LBB19_23, $15(%rip) - WORD $0x8949; BYTE $0x16 // movq %rdx, (%r14) - LONG $0xfe03c748; WORD $0xffff; BYTE $0xff // movq $-2, (%rbx) - LONG $0x00018fe9; BYTE $0x00 // jmp LBB19_52, $399(%rip) - -LBB19_23: - LONG $0x00c845c7; WORD $0x0000; BYTE $0x00 // movl $0, $-56(%rbp) - WORD $0x8948; BYTE $0xd0 // movq %rdx, %rax +LBB14_22: + WORD $0x894c; BYTE $0x0e // movq %r9, (%rsi) + LONG $0xffff13e9; BYTE $0xff // jmp LBB14_8, $-237(%rip) -LBB19_24: - WORD $0xd231 // xorl %edx, %edx - WORD $0xc985 // testl %ecx, %ecx - WORD $0x9f0f; BYTE $0xc2 // setg %dl - WORD $0x5589; BYTE $0xbc // movl %edx, $-68(%rbp) - WORD $0x854d; BYTE $0xe4 // testq %r12, %r12 - LONG $0x005d850f; WORD $0x0000 // jne LBB19_33, $93(%rip) - WORD $0xc985 // testl %ecx, %ecx - LONG $0x0055850f; WORD $0x0000 // jne LBB19_33, $85(%rip) - WORD $0x394c; BYTE $0xe8 // cmpq %r13, %rax - LONG $0x0044830f; WORD $0x0000 // jae LBB19_31, $68(%rip) - WORD $0xc689 // movl %eax, %esi - WORD $0x2944; BYTE $0xee // subl %r13d, %esi - WORD $0x3145; BYTE $0xc0 // xorl %r8d, %r8d - WORD $0xc931 // xorl %ecx, %ecx - QUAD $0x9090909090909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 +LBB14_23: + WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d + WORD $0x3145; BYTE $0xd2 // xorl %r10d, %r10d + WORD $0xc931 // xorl %ecx, %ecx + +LBB14_24: + WORD $0xd231 // xorl %edx, %edx + WORD $0xc985 // testl %ecx, %ecx + WORD $0x9f0f; BYTE $0xc2 // setg %dl + WORD $0x5589; BYTE $0xc4 // movl %edx, $-60(%rbp) + WORD $0xb041; BYTE $0x01 // movb $1, %r8b + LONG $0x2eff8040 // cmpb $46, %dil + LONG $0x003b850f; WORD $0x0000 // jne LBB14_30, $59(%rip) + WORD $0xff48; BYTE $0xc0 // incq %rax + LONG $0x0806c749; WORD $0x0000; BYTE $0x00 // movq $8, (%r14) + WORD $0x394c; BYTE $0xe8 // cmpq %r13, %rax + LONG $0x0268830f; WORD $0x0000 // jae LBB14_68, $616(%rip) + LONG $0x07148a41 // movb (%r15,%rax), %dl + WORD $0xc280; BYTE $0xd0 // addb $-48, %dl + WORD $0xfa80; BYTE $0x0a // cmpb $10, %dl + LONG $0x0401830f; WORD $0x0000 // jae LBB14_91, $1025(%rip) + WORD $0x3145; BYTE $0xc0 // xorl %r8d, %r8d + LONG $0x000010e9; BYTE $0x00 // jmp LBB14_30, $16(%rip) + +LBB14_28: + WORD $0x894c; BYTE $0xe8 // movq %r13, %rax + +LBB14_29: + WORD $0xd231 // xorl %edx, %edx + WORD $0xc985 // testl %ecx, %ecx + WORD $0x9f0f; BYTE $0xc2 // setg %dl + WORD $0x5589; BYTE $0xc4 // movl %edx, $-60(%rbp) + WORD $0xb041; BYTE $0x01 // movb $1, %r8b -LBB19_28: +LBB14_30: + WORD $0xc985 // testl %ecx, %ecx + LONG $0x0056850f; WORD $0x0000 // jne LBB14_39, $86(%rip) + WORD $0x854d; BYTE $0xe4 // testq %r12, %r12 + LONG $0x004d850f; WORD $0x0000 // jne LBB14_39, $77(%rip) + WORD $0x394c; BYTE $0xe8 // cmpq %r13, %rax + LONG $0x003c830f; WORD $0x0000 // jae LBB14_37, $60(%rip) + WORD $0xc689 // movl %eax, %esi + WORD $0x2944; BYTE $0xee // subl %r13d, %esi + WORD $0x3145; BYTE $0xd2 // xorl %r10d, %r10d + WORD $0xc931 // xorl %ecx, %ecx + QUAD $0x9090909090909090 // .p2align 4, 0x90 + +LBB14_34: LONG $0x073c8041; BYTE $0x30 // cmpb $48, (%r15,%rax) - LONG $0x0029850f; WORD $0x0000 // jne LBB19_32, $41(%rip) + LONG $0x0024850f; WORD $0x0000 // jne LBB14_38, $36(%rip) WORD $0xff48; BYTE $0xc0 // incq %rax WORD $0xc9ff // decl %ecx WORD $0x3949; BYTE $0xc5 // cmpq %rax, %r13 - LONG $0xffe7850f; WORD $0xffff // jne LBB19_28, $-25(%rip) + LONG $0xffe7850f; WORD $0xffff // jne LBB14_34, $-25(%rip) WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d - WORD $0x458b; BYTE $0xc8 // movl $-56(%rbp), %eax - WORD $0xc084 // testb %al, %al - LONG $0x0144850f; WORD $0x0000 // jne LBB19_54, $324(%rip) + WORD $0x8445; BYTE $0xc0 // testb %r8b, %r8b + LONG $0x0122850f; WORD $0x0000 // jne LBB14_58, $290(%rip) + LONG $0x000152e9; BYTE $0x00 // jmp LBB14_62, $338(%rip) -LBB19_59: - WORD $0x558b; BYTE $0xd4 // movl $-44(%rbp), %edx - LONG $0x000173e9; BYTE $0x00 // jmp LBB19_60, $371(%rip) - -LBB19_31: +LBB14_37: WORD $0xc931 // xorl %ecx, %ecx - WORD $0x3145; BYTE $0xc0 // xorl %r8d, %r8d + WORD $0x3145; BYTE $0xd2 // xorl %r10d, %r10d -LBB19_32: +LBB14_38: WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d -LBB19_33: +LBB14_39: WORD $0x394c; BYTE $0xe8 // cmpq %r13, %rax - LONG $0x004c830f; WORD $0x0000 // jae LBB19_39, $76(%rip) - LONG $0x12f88341 // cmpl $18, %r8d - LONG $0x00428f0f; WORD $0x0000 // jg LBB19_39, $66(%rip) + LONG $0x0051830f; WORD $0x0000 // jae LBB14_45, $81(%rip) + LONG $0x12fa8341 // cmpl $18, %r10d + LONG $0x00478f0f; WORD $0x0000 // jg LBB14_45, $71(%rip) LONG $0xffd0b941; WORD $0xffff // movl $4294967248, %r9d + LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 - // .p2align 4, 0x90 -LBB19_36: +LBB14_42: LONG $0x14b60f41; BYTE $0x07 // movzbl (%r15,%rax), %edx WORD $0x7a8d; BYTE $0xd0 // leal $-48(%rdx), %edi LONG $0x09ff8040 // cmpb $9, %dil - LONG $0x002a870f; WORD $0x0000 // ja LBB19_39, $42(%rip) + LONG $0x002a870f; WORD $0x0000 // ja LBB14_45, $42(%rip) LONG $0xa43c8d4b // leaq (%r12,%r12,4), %rdi WORD $0x0144; BYTE $0xca // addl %r9d, %edx LONG $0x7a248d4c // leaq (%rdx,%rdi,2), %r12 WORD $0xc9ff // decl %ecx WORD $0xff48; BYTE $0xc0 // incq %rax WORD $0x394c; BYTE $0xe8 // cmpq %r13, %rax - LONG $0x0011830f; WORD $0x0000 // jae LBB19_39, $17(%rip) - LONG $0x01508d41 // leal $1(%r8), %edx - LONG $0x12f88341 // cmpl $18, %r8d - WORD $0x8941; BYTE $0xd0 // movl %edx, %r8d - LONG $0xffc48c0f; WORD $0xffff // jl LBB19_36, $-60(%rip) + LONG $0x0011830f; WORD $0x0000 // jae LBB14_45, $17(%rip) + LONG $0x01528d41 // leal $1(%r10), %edx + LONG $0x12fa8341 // cmpl $18, %r10d + WORD $0x8941; BYTE $0xd2 // movl %edx, %r10d + LONG $0xffc48c0f; WORD $0xffff // jl LBB14_42, $-60(%rip) -LBB19_39: - WORD $0x394c; BYTE $0xe8 // cmpq %r13, %rax - LONG $0x00c6830f; WORD $0x0000 // jae LBB19_53, $198(%rip) - LONG $0x34b60f41; BYTE $0x07 // movzbl (%r15,%rax), %esi - WORD $0x568d; BYTE $0xd0 // leal $-48(%rsi), %edx - WORD $0xfa80; BYTE $0x09 // cmpb $9, %dl - LONG $0x0030870f; WORD $0x0000 // ja LBB19_45, $48(%rip) - LONG $0xff558d49 // leaq $-1(%r13), %rdx - LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 +LBB14_45: + WORD $0x394c; BYTE $0xe8 // cmpq %r13, %rax + LONG $0x00a4830f; WORD $0x0000 // jae LBB14_57, $164(%rip) + LONG $0x07348a41 // movb (%r15,%rax), %sil + WORD $0x568d; BYTE $0xd0 // leal $-48(%rsi), %edx + WORD $0xfa80; BYTE $0x09 // cmpb $9, %dl + LONG $0x0030870f; WORD $0x0000 // ja LBB14_51, $48(%rip) + LONG $0xff7d8d49 // leaq $-1(%r13), %rdi + LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 -LBB19_42: - WORD $0x3948; BYTE $0xc2 // cmpq %rax, %rdx - LONG $0x0180840f; WORD $0x0000 // je LBB19_58, $384(%rip) +LBB14_48: + WORD $0x3948; BYTE $0xc7 // cmpq %rax, %rdi + LONG $0x0167840f; WORD $0x0000 // je LBB14_69, $359(%rip) LONG $0x74b60f41; WORD $0x0107 // movzbl $1(%r15,%rax), %esi - WORD $0x7e8d; BYTE $0xd0 // leal $-48(%rsi), %edi WORD $0xff48; BYTE $0xc0 // incq %rax - LONG $0x09ff8040 // cmpb $9, %dil - LONG $0xffe1860f; WORD $0xffff // jbe LBB19_42, $-31(%rip) - LONG $0x01bc45c7; WORD $0x0000; BYTE $0x00 // movl $1, $-68(%rbp) - -LBB19_45: - LONG $0xd6b60f40 // movzbl %sil, %edx - WORD $0xca83; BYTE $0x20 // orl $32, %edx - WORD $0xfa83; BYTE $0x65 // cmpl $101, %edx - LONG $0x0075850f; WORD $0x0000 // jne LBB19_53, $117(%rip) + WORD $0x568d; BYTE $0xd0 // leal $-48(%rsi), %edx + WORD $0xfa80; BYTE $0x09 // cmpb $9, %dl + LONG $0xffe2860f; WORD $0xffff // jbe LBB14_48, $-30(%rip) + LONG $0x01c445c7; WORD $0x0000; BYTE $0x00 // movl $1, $-60(%rbp) + +LBB14_51: + LONG $0x20ce8040 // orb $32, %sil + LONG $0x65fe8040 // cmpb $101, %sil + LONG $0x0056850f; WORD $0x0000 // jne LBB14_57, $86(%rip) LONG $0x01788d48 // leaq $1(%rax), %rdi - LONG $0x0803c748; WORD $0x0000; BYTE $0x00 // movq $8, (%rbx) + LONG $0x0806c749; WORD $0x0000; BYTE $0x00 // movq $8, (%r14) WORD $0x394c; BYTE $0xef // cmpq %r13, %rdi - LONG $0x0048830f; WORD $0x0000 // jae LBB19_51, $72(%rip) - LONG $0x34b60f41; BYTE $0x3f // movzbl (%r15,%rdi), %esi - WORD $0xfe83; BYTE $0x2d // cmpl $45, %esi - LONG $0x000f840f; WORD $0x0000 // je LBB19_49, $15(%rip) + LONG $0x011d830f; WORD $0x0000 // jae LBB14_68, $285(%rip) + LONG $0x3f348a41 // movb (%r15,%rdi), %sil + LONG $0x2dfe8040 // cmpb $45, %sil + LONG $0x0010840f; WORD $0x0000 // je LBB14_55, $16(%rip) LONG $0x0001b841; WORD $0x0000 // movl $1, %r8d - WORD $0xfe83; BYTE $0x2b // cmpl $43, %esi - LONG $0x02a8850f; WORD $0x0000 // jne LBB19_86, $680(%rip) + LONG $0x2bfe8040 // cmpb $43, %sil + LONG $0x0298850f; WORD $0x0000 // jne LBB14_89, $664(%rip) -LBB19_49: +LBB14_55: LONG $0x02c08348 // addq $2, %rax WORD $0x394c; BYTE $0xe8 // cmpq %r13, %rax - WORD $0x558b; BYTE $0xd4 // movl $-44(%rbp), %edx - LONG $0x001b830f; WORD $0x0000 // jae LBB19_51, $27(%rip) - WORD $0xff31 // xorl %edi, %edi + LONG $0x00f2830f; WORD $0x0000 // jae LBB14_68, $242(%rip) + WORD $0xd231 // xorl %edx, %edx LONG $0x2bfe8040 // cmpb $43, %sil - LONG $0xc7940f40 // sete %dil - LONG $0x3f048d44 // leal (%rdi,%rdi), %r8d - WORD $0xff41; BYTE $0xc8 // decl %r8d - LONG $0x34b60f41; BYTE $0x07 // movzbl (%r15,%rax), %esi - LONG $0x000283e9; BYTE $0x00 // jmp LBB19_87, $643(%rip) + WORD $0x940f; BYTE $0xc2 // sete %dl + LONG $0x12448d44; BYTE $0xff // leal $-1(%rdx,%rdx), %r8d + LONG $0x07348a41 // movb (%r15,%rax), %sil + LONG $0x000277e9; BYTE $0x00 // jmp LBB14_90, $631(%rip) -LBB19_51: - WORD $0x894d; BYTE $0x2e // movq %r13, (%r14) - LONG $0xff03c748; WORD $0xffff; BYTE $0xff // movq $-1, (%rbx) - -LBB19_52: - LONG $0x38c48348 // addq $56, %rsp - BYTE $0x5b // popq %rbx - WORD $0x5c41 // popq %r12 - WORD $0x5d41 // popq %r13 - WORD $0x5e41 // popq %r14 - WORD $0x5f41 // popq %r15 - BYTE $0x5d // popq %rbp - BYTE $0xc3 // retq - -LBB19_53: +LBB14_57: WORD $0xce89 // movl %ecx, %esi WORD $0x8949; BYTE $0xc5 // movq %rax, %r13 - WORD $0x458b; BYTE $0xc8 // movl $-56(%rbp), %eax - WORD $0xc084 // testb %al, %al - LONG $0xfebc840f; WORD $0xffff // je LBB19_59, $-324(%rip) + WORD $0x8445; BYTE $0xc0 // testb %r8b, %r8b + LONG $0x0035840f; WORD $0x0000 // je LBB14_62, $53(%rip) -LBB19_54: +LBB14_58: WORD $0xf685 // testl %esi, %esi - WORD $0x558b; BYTE $0xd4 // movl $-44(%rbp), %edx - LONG $0x0025850f; WORD $0x0000 // jne LBB19_57, $37(%rip) + LONG $0x0026850f; WORD $0x0000 // jne LBB14_61, $38(%rip) QUAD $0x000000000000b848; WORD $0x8000 // movabsq $-9223372036854775808, %rax - WORD $0x6348; BYTE $0xca // movslq %edx, %rcx + LONG $0xc04d6348 // movslq $-64(%rbp), %rcx WORD $0x854d; BYTE $0xe4 // testq %r12, %r12 - LONG $0x00e7890f; WORD $0x0000 // jns LBB19_68, $231(%rip) - WORD $0x894c; BYTE $0xe7 // movq %r12, %rdi - WORD $0x2148; BYTE $0xcf // andq %rcx, %rdi - WORD $0x3948; BYTE $0xc7 // cmpq %rax, %rdi - LONG $0x00d8840f; WORD $0x0000 // je LBB19_68, $216(%rip) + LONG $0x00f2890f; WORD $0x0000 // jns LBB14_72, $242(%rip) + WORD $0x894c; BYTE $0xe2 // movq %r12, %rdx + WORD $0x2148; BYTE $0xca // andq %rcx, %rdx + WORD $0x3948; BYTE $0xc2 // cmpq %rax, %rdx + LONG $0x00e3840f; WORD $0x0000 // je LBB14_72, $227(%rip) -LBB19_57: - LONG $0x0803c748; WORD $0x0000; BYTE $0x00 // movq $8, (%rbx) +LBB14_61: + LONG $0x0806c749; WORD $0x0000; BYTE $0x00 // movq $8, (%r14) -LBB19_60: +LBB14_62: + QUAD $0x00000000b845c748 // movq $0, $-72(%rbp) LONG $0x6ef9c1c4; BYTE $0xc4 // vmovq %r12, %xmm0 - QUAD $0xfffffc510562f9c5 // vpunpckldq $-943(%rip), %xmm0, %xmm0 /* LCPI19_0(%rip) */ - QUAD $0x00000000b045c748 // movq $0, $-80(%rbp) - QUAD $0xfffffc51055cf9c5 // vsubpd $-943(%rip), %xmm0, %xmm0 /* LCPI19_1(%rip) */ + QUAD $0xfffffc2f0562f9c5 // vpunpckldq $-977(%rip), %xmm0, %xmm0 /* LCPI14_0(%rip) */ + QUAD $0xfffffc37055cf9c5 // vsubpd $-969(%rip), %xmm0, %xmm0 /* LCPI14_1(%rip) */ LONG $0x0579e3c4; WORD $0x01c8 // vpermilpd $1, %xmm0, %xmm1 LONG $0xc058f3c5 // vaddsd %xmm0, %xmm1, %xmm0 - LONG $0x4511fbc5; BYTE $0xc0 // vmovsd %xmm0, $-64(%rbp) + LONG $0x4511fbc5; BYTE $0xc8 // vmovsd %xmm0, $-56(%rbp) WORD $0x894c; BYTE $0xe0 // movq %r12, %rax LONG $0x34e8c148 // shrq $52, %rax - LONG $0x010d850f; WORD $0x0000 // jne LBB19_73, $269(%rip) + LONG $0x011f850f; WORD $0x0000 // jne LBB14_77, $287(%rip) LONG $0x7ef9e1c4; BYTE $0xc1 // vmovq %xmm0, %rcx - WORD $0xd089 // movl %edx, %eax + WORD $0x458b; BYTE $0xc0 // movl $-64(%rbp), %eax WORD $0xe8c1; BYTE $0x1f // shrl $31, %eax LONG $0x3fe0c148 // shlq $63, %rax WORD $0x0948; BYTE $0xc8 // orq %rcx, %rax - LONG $0xc0458948 // movq %rax, $-64(%rbp) + LONG $0xc8458948 // movq %rax, $-56(%rbp) WORD $0x854d; BYTE $0xe4 // testq %r12, %r12 - LONG $0x018a840f; WORD $0x0000 // je LBB19_81, $394(%rip) + LONG $0x019f840f; WORD $0x0000 // je LBB14_85, $415(%rip) WORD $0xf685 // testl %esi, %esi - LONG $0x0182840f; WORD $0x0000 // je LBB19_81, $386(%rip) + LONG $0x0197840f; WORD $0x0000 // je LBB14_85, $407(%rip) LONG $0x6ef9e1c4; BYTE $0xc0 // vmovq %rax, %xmm0 WORD $0x468d; BYTE $0xff // leal $-1(%rsi), %eax WORD $0xf883; BYTE $0x24 // cmpl $36, %eax - LONG $0x0040870f; WORD $0x0000 // ja LBB19_66, $64(%rip) + LONG $0x004a870f; WORD $0x0000 // ja LBB14_70, $74(%rip) WORD $0xfe83; BYTE $0x17 // cmpl $23, %esi - LONG $0x0093820f; WORD $0x0000 // jb LBB19_69, $147(%rip) + LONG $0x00a48c0f; WORD $0x0000 // jl LBB14_73, $164(%rip) WORD $0x468d; BYTE $0xea // leal $-22(%rsi), %eax - LONG $0x8b0d8d48; WORD $0x00e1; BYTE $0x00 // leaq $57739(%rip), %rcx /* _P10_TAB(%rip) */ + LONG $0xc00d8d48; WORD $0x00ed; BYTE $0x00 // leaq $60864(%rip), %rcx /* _P10_TAB(%rip) */ LONG $0x0459fbc5; BYTE $0xc1 // vmulsd (%rcx,%rax,8), %xmm0, %xmm0 - LONG $0x4511fbc5; BYTE $0xc0 // vmovsd %xmm0, $-64(%rbp) + LONG $0x4511fbc5; BYTE $0xc8 // vmovsd %xmm0, $-56(%rbp) LONG $0x000016b8; BYTE $0x00 // movl $22, %eax - LONG $0x000077e9; BYTE $0x00 // jmp LBB19_70, $119(%rip) + LONG $0x000088e9; BYTE $0x00 // jmp LBB14_74, $136(%rip) + +LBB14_68: + LONG $0xd0458b48 // movq $-48(%rbp), %rax + WORD $0x894c; BYTE $0x28 // movq %r13, (%rax) + LONG $0xfffc66e9; BYTE $0xff // jmp LBB14_7, $-922(%rip) -LBB19_58: - LONG $0x01bc45c7; WORD $0x0000; BYTE $0x00 // movl $1, $-68(%rbp) +LBB14_69: + LONG $0x01c445c7; WORD $0x0000; BYTE $0x00 // movl $1, $-60(%rbp) WORD $0xce89 // movl %ecx, %esi - WORD $0x458b; BYTE $0xc8 // movl $-56(%rbp), %eax - WORD $0xc084 // testb %al, %al - LONG $0xff1e850f; WORD $0xffff // jne LBB19_54, $-226(%rip) - LONG $0xfffdd5e9; BYTE $0xff // jmp LBB19_59, $-555(%rip) + WORD $0x8445; BYTE $0xc0 // testb %r8b, %r8b + LONG $0xff15850f; WORD $0xffff // jne LBB14_58, $-235(%rip) + LONG $0xffff45e9; BYTE $0xff // jmp LBB14_62, $-187(%rip) -LBB19_66: +LBB14_70: WORD $0xfe83; BYTE $0xea // cmpl $-22, %esi - LONG $0x008d820f; WORD $0x0000 // jb LBB19_73, $141(%rip) + LONG $0x0094820f; WORD $0x0000 // jb LBB14_77, $148(%rip) WORD $0xdef7 // negl %esi - LONG $0x4c058d48; WORD $0x00e1; BYTE $0x00 // leaq $57676(%rip), %rax /* _P10_TAB(%rip) */ + LONG $0x77058d48; WORD $0x00ed; BYTE $0x00 // leaq $60791(%rip), %rax /* _P10_TAB(%rip) */ LONG $0x045efbc5; BYTE $0xf0 // vdivsd (%rax,%rsi,8), %xmm0, %xmm0 - LONG $0x4511fbc5; BYTE $0xc0 // vmovsd %xmm0, $-64(%rbp) - LONG $0x0000d7e9; BYTE $0x00 // jmp LBB19_77, $215(%rip) + LONG $0x4511fbc5; BYTE $0xc8 // vmovsd %xmm0, $-56(%rbp) + LONG $0x0000dee9; BYTE $0x00 // jmp LBB14_81, $222(%rip) -LBB19_68: +LBB14_72: LONG $0x6ef9c1c4; BYTE $0xc4 // vmovq %r12, %xmm0 LONG $0xe1af0f4c // imulq %rcx, %r12 - QUAD $0xfffffb7c0562f9c5 // vpunpckldq $-1156(%rip), %xmm0, %xmm0 /* LCPI19_0(%rip) */ - QUAD $0xfffffb84055cf9c5 // vsubpd $-1148(%rip), %xmm0, %xmm0 /* LCPI19_1(%rip) */ - LONG $0x1063894c // movq %r12, $16(%rbx) + QUAD $0xfffffb570562f9c5 // vpunpckldq $-1193(%rip), %xmm0, %xmm0 /* LCPI14_0(%rip) */ + QUAD $0xfffffb5f055cf9c5 // vsubpd $-1185(%rip), %xmm0, %xmm0 /* LCPI14_1(%rip) */ + LONG $0x1066894d // movq %r12, $16(%r14) LONG $0x0579e3c4; WORD $0x01c8 // vpermilpd $1, %xmm0, %xmm1 LONG $0xc058f3c5 // vaddsd %xmm0, %xmm1, %xmm0 WORD $0x2148; BYTE $0xc8 // andq %rcx, %rax LONG $0x7ef9e1c4; BYTE $0xc1 // vmovq %xmm0, %rcx WORD $0x0948; BYTE $0xc1 // orq %rax, %rcx - LONG $0x084b8948 // movq %rcx, $8(%rbx) - LONG $0x000109e9; BYTE $0x00 // jmp LBB19_85, $265(%rip) + LONG $0x084e8949 // movq %rcx, $8(%r14) + LONG $0xd0458b48 // movq $-48(%rbp), %rax + WORD $0x894c; BYTE $0x28 // movq %r13, (%rax) + LONG $0xfffbf3e9; BYTE $0xff // jmp LBB14_8, $-1037(%rip) -LBB19_69: +LBB14_73: WORD $0xf089 // movl %esi, %eax -LBB19_70: - QUAD $0xfffffb68052ef9c5 // vucomisd $-1176(%rip), %xmm0 /* LCPI19_2(%rip) */ - LONG $0x002a870f; WORD $0x0000 // ja LBB19_73, $42(%rip) - QUAD $0xfffffb620d10fbc5 // vmovsd $-1182(%rip), %xmm1 /* LCPI19_3(%rip) */ +LBB14_74: + QUAD $0xfffffb3c052ef9c5 // vucomisd $-1220(%rip), %xmm0 /* LCPI14_2(%rip) */ + LONG $0x002a870f; WORD $0x0000 // ja LBB14_77, $42(%rip) + QUAD $0xfffffb360d10fbc5 // vmovsd $-1226(%rip), %xmm1 /* LCPI14_3(%rip) */ LONG $0xc82ef9c5 // vucomisd %xmm0, %xmm1 - LONG $0x0018870f; WORD $0x0000 // ja LBB19_73, $24(%rip) + LONG $0x0018870f; WORD $0x0000 // ja LBB14_77, $24(%rip) WORD $0xc089 // movl %eax, %eax - LONG $0xd70d8d48; WORD $0x00e0; BYTE $0x00 // leaq $57559(%rip), %rcx /* _P10_TAB(%rip) */ + LONG $0xfb0d8d48; WORD $0x00ec; BYTE $0x00 // leaq $60667(%rip), %rcx /* _P10_TAB(%rip) */ LONG $0x0459fbc5; BYTE $0xc1 // vmulsd (%rcx,%rax,8), %xmm0, %xmm0 - LONG $0x4511fbc5; BYTE $0xc0 // vmovsd %xmm0, $-64(%rbp) - LONG $0x000062e9; BYTE $0x00 // jmp LBB19_77, $98(%rip) + LONG $0x4511fbc5; BYTE $0xc8 // vmovsd %xmm0, $-56(%rbp) + LONG $0x000062e9; BYTE $0x00 // jmp LBB14_81, $98(%rip) -LBB19_73: - LONG $0xa05d894c // movq %r11, $-96(%rbp) - LONG $0xc855894c // movq %r10, $-56(%rbp) - LONG $0xc04d8d48 // leaq $-64(%rbp), %rcx +LBB14_77: + LONG $0xa85d894c // movq %r11, $-88(%rbp) + LONG $0xc84d8d48 // leaq $-56(%rbp), %rcx WORD $0x894c; BYTE $0xe7 // movq %r12, %rdi - LONG $0xa8758948 // movq %rsi, $-88(%rbp) - LONG $0xffdf90e8; BYTE $0xff // callq _atof_eisel_lemire64, $-8304(%rip) + WORD $0x5d8b; BYTE $0xc0 // movl $-64(%rbp), %ebx + WORD $0xda89 // movl %ebx, %edx + LONG $0xb0758948 // movq %rsi, $-80(%rbp) + LONG $0xffe613e8; BYTE $0xff // callq _atof_eisel_lemire64, $-6637(%rip) WORD $0xc084 // testb %al, %al - LONG $0x004c840f; WORD $0x0000 // je LBB19_79, $76(%rip) - LONG $0x00bc7d83 // cmpl $0, $-68(%rbp) - LONG $0x006d840f; WORD $0x0000 // je LBB19_80, $109(%rip) + LONG $0x004b840f; WORD $0x0000 // je LBB14_83, $75(%rip) + LONG $0xb0758b48 // movq $-80(%rbp), %rsi + LONG $0x00c47d83 // cmpl $0, $-60(%rbp) + LONG $0x006c840f; WORD $0x0000 // je LBB14_84, $108(%rip) WORD $0xff49; BYTE $0xc4 // incq %r12 - LONG $0xb04d8d48 // leaq $-80(%rbp), %rcx + LONG $0xb84d8d48 // leaq $-72(%rbp), %rcx WORD $0x894c; BYTE $0xe7 // movq %r12, %rdi - LONG $0xa8758b48 // movq $-88(%rbp), %rsi - WORD $0x558b; BYTE $0xd4 // movl $-44(%rbp), %edx - LONG $0xffdf68e8; BYTE $0xff // callq _atof_eisel_lemire64, $-8344(%rip) + WORD $0xda89 // movl %ebx, %edx + LONG $0xffe5ece8; BYTE $0xff // callq _atof_eisel_lemire64, $-6676(%rip) WORD $0xc084 // testb %al, %al - LONG $0x0024840f; WORD $0x0000 // je LBB19_79, $36(%rip) - LONG $0x4d10fbc5; BYTE $0xb0 // vmovsd $-80(%rbp), %xmm1 - LONG $0x4510fbc5; BYTE $0xc0 // vmovsd $-64(%rbp), %xmm0 + LONG $0x0024840f; WORD $0x0000 // je LBB14_83, $36(%rip) + LONG $0x4d10fbc5; BYTE $0xb8 // vmovsd $-72(%rbp), %xmm1 + LONG $0x4510fbc5; BYTE $0xc8 // vmovsd $-56(%rbp), %xmm0 LONG $0xc82ef9c5 // vucomisd %xmm0, %xmm1 - LONG $0x0010850f; WORD $0x0000 // jne LBB19_79, $16(%rip) - LONG $0x000a8a0f; WORD $0x0000 // jp LBB19_79, $10(%rip) + LONG $0x0010850f; WORD $0x0000 // jne LBB14_83, $16(%rip) + LONG $0x000a8a0f; WORD $0x0000 // jp LBB14_83, $10(%rip) -LBB19_77: +LBB14_81: LONG $0x7ef9e1c4; BYTE $0xc0 // vmovq %xmm0, %rax - LONG $0x00002fe9; BYTE $0x00 // jmp LBB19_81, $47(%rip) + LONG $0x000033e9; BYTE $0x00 // jmp LBB14_85, $51(%rip) -LBB19_79: - WORD $0x8b49; BYTE $0x06 // movq (%r14), %rax +LBB14_83: + LONG $0xd05d8b48 // movq $-48(%rbp), %rbx + WORD $0x8b48; BYTE $0x03 // movq (%rbx), %rax WORD $0x0149; BYTE $0xc7 // addq %rax, %r15 WORD $0x894c; BYTE $0xee // movq %r13, %rsi WORD $0x2948; BYTE $0xc6 // subq %rax, %rsi WORD $0x894c; BYTE $0xff // movq %r15, %rdi - LONG $0xc8558b48 // movq $-56(%rbp), %rdx - LONG $0xa04d8b48 // movq $-96(%rbp), %rcx - LONG $0xffe8a0e8; BYTE $0xff // callq _atof_native, $-5984(%rip) - LONG $0x4511fbc5; BYTE $0xc0 // vmovsd %xmm0, $-64(%rbp) + LONG $0xa0558b48 // movq $-96(%rbp), %rdx + LONG $0xa84d8b48 // movq $-88(%rbp), %rcx + LONG $0xffeaf0e8; BYTE $0xff // callq _atof_native, $-5392(%rip) + LONG $0x4511fbc5; BYTE $0xc8 // vmovsd %xmm0, $-56(%rbp) LONG $0x7ef9e1c4; BYTE $0xc0 // vmovq %xmm0, %rax - LONG $0x000009e9; BYTE $0x00 // jmp LBB19_82, $9(%rip) + LONG $0x000008e9; BYTE $0x00 // jmp LBB14_86, $8(%rip) -LBB19_80: - LONG $0xc0458b48 // movq $-64(%rbp), %rax +LBB14_84: + LONG $0xc8458b48 // movq $-56(%rbp), %rax -LBB19_81: - LONG $0x6ef9e1c4; BYTE $0xc0 // vmovq %rax, %xmm0 +LBB14_85: + LONG $0xd05d8b48 // movq $-48(%rbp), %rbx -LBB19_82: +LBB14_86: QUAD $0x000000000000b948; WORD $0x8000 // movabsq $-9223372036854775808, %rcx WORD $0xff48; BYTE $0xc9 // decq %rcx WORD $0x2148; BYTE $0xc1 // andq %rax, %rcx - QUAD $0x000000000000b848; WORD $0x7ff0 // movabsq $9218868437227405312, %rax - WORD $0x3948; BYTE $0xc1 // cmpq %rax, %rcx - LONG $0x0007850f; WORD $0x0000 // jne LBB19_84, $7(%rip) - LONG $0xf803c748; WORD $0xffff; BYTE $0xff // movq $-8, (%rbx) + QUAD $0x000000000000ba48; WORD $0x7ff0 // movabsq $9218868437227405312, %rdx + WORD $0x3948; BYTE $0xd1 // cmpq %rdx, %rcx + LONG $0x0007850f; WORD $0x0000 // jne LBB14_88, $7(%rip) + LONG $0xf806c749; WORD $0xffff; BYTE $0xff // movq $-8, (%r14) -LBB19_84: - LONG $0x4311fbc5; BYTE $0x08 // vmovsd %xmm0, $8(%rbx) +LBB14_88: + LONG $0x08468949 // movq %rax, $8(%r14) + WORD $0x894c; BYTE $0x2b // movq %r13, (%rbx) + LONG $0xfffae0e9; BYTE $0xff // jmp LBB14_8, $-1312(%rip) -LBB19_85: - WORD $0x894d; BYTE $0x2e // movq %r13, (%r14) - LONG $0xfffd8de9; BYTE $0xff // jmp LBB19_52, $-627(%rip) - -LBB19_86: +LBB14_89: WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax - WORD $0x558b; BYTE $0xd4 // movl $-44(%rbp), %edx -LBB19_87: - LONG $0xc6c68040 // addb $-58, %sil - LONG $0xf6fe8040 // cmpb $-10, %sil - LONG $0xfadb820f; WORD $0xffff // jb LBB19_5, $-1317(%rip) - WORD $0xf631 // xorl %esi, %esi - WORD $0x394c; BYTE $0xe8 // cmpq %r13, %rax - LONG $0x0035830f; WORD $0x0000 // jae LBB19_93, $53(%rip) - WORD $0xf631 // xorl %esi, %esi +LBB14_90: + WORD $0x7e8d; BYTE $0xd0 // leal $-48(%rsi), %edi + LONG $0x09ff8040 // cmpb $9, %dil + LONG $0x0013860f; WORD $0x0000 // jbe LBB14_92, $19(%rip) -LBB19_90: - LONG $0x0cb60f45; BYTE $0x07 // movzbl (%r15,%rax), %r9d - LONG $0xd0798d41 // leal $-48(%r9), %edi +LBB14_91: + LONG $0xd04d8b48 // movq $-48(%rbp), %rcx + WORD $0x8948; BYTE $0x01 // movq %rax, (%rcx) + LONG $0xfe06c749; WORD $0xffff; BYTE $0xff // movq $-2, (%r14) + LONG $0xfffabde9; BYTE $0xff // jmp LBB14_8, $-1347(%rip) + +LBB14_92: + WORD $0x394c; BYTE $0xe8 // cmpq %r13, %rax + LONG $0x0049830f; WORD $0x0000 // jae LBB14_98, $73(%rip) LONG $0x09ff8040 // cmpb $9, %dil - LONG $0x0020870f; WORD $0x0000 // ja LBB19_93, $32(%rip) - LONG $0x2710fe81; WORD $0x0000 // cmpl $10000, %esi - WORD $0x3c8d; BYTE $0xb6 // leal (%rsi,%rsi,4), %edi - LONG $0x797c8d41; BYTE $0xd0 // leal $-48(%r9,%rdi,2), %edi - WORD $0x4c0f; BYTE $0xf7 // cmovll %edi, %esi + LONG $0x003f870f; WORD $0x0000 // ja LBB14_98, $63(%rip) + LONG $0xff4d8d4d // leaq $-1(%r13), %r9 + WORD $0xff31 // xorl %edi, %edi + +LBB14_95: + WORD $0xfa89 // movl %edi, %edx + LONG $0x2710ff81; WORD $0x0000 // cmpl $10000, %edi + WORD $0x3c8d; BYTE $0x92 // leal (%rdx,%rdx,4), %edi + LONG $0xf6b60f40 // movzbl %sil, %esi + LONG $0xd07e7c8d // leal $-48(%rsi,%rdi,2), %edi + WORD $0x4d0f; BYTE $0xfa // cmovgel %edx, %edi + WORD $0x3949; BYTE $0xc1 // cmpq %rax, %r9 + LONG $0x0021840f; WORD $0x0000 // je LBB14_99, $33(%rip) + LONG $0x74b60f41; WORD $0x0107 // movzbl $1(%r15,%rax), %esi WORD $0xff48; BYTE $0xc0 // incq %rax - WORD $0x3949; BYTE $0xc5 // cmpq %rax, %r13 - LONG $0xffd0850f; WORD $0xffff // jne LBB19_90, $-48(%rip) - WORD $0x894c; BYTE $0xe8 // movq %r13, %rax + WORD $0x568d; BYTE $0xd0 // leal $-48(%rsi), %edx + WORD $0xfa80; BYTE $0x0a // cmpb $10, %dl + LONG $0xffcc820f; WORD $0xffff // jb LBB14_95, $-52(%rip) + LONG $0x00000ae9; BYTE $0x00 // jmp LBB14_100, $10(%rip) -LBB19_93: - LONG $0xf0af0f41 // imull %r8d, %esi - WORD $0xce01 // addl %ecx, %esi - WORD $0x8949; BYTE $0xc5 // movq %rax, %r13 - LONG $0xfffd81e9; BYTE $0xff // jmp LBB19_60, $-639(%rip) - QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 +LBB14_98: + WORD $0xff31 // xorl %edi, %edi + LONG $0x000003e9; BYTE $0x00 // jmp LBB14_100, $3(%rip) + +LBB14_99: + WORD $0x894c; BYTE $0xe8 // movq %r13, %rax + +LBB14_100: + WORD $0x8948; BYTE $0xfe // movq %rdi, %rsi + LONG $0xf0af0f41 // imull %r8d, %esi + WORD $0xce01 // addl %ecx, %esi + WORD $0x8949; BYTE $0xc5 // movq %rax, %r13 + LONG $0xfffd3fe9; BYTE $0xff // jmp LBB14_62, $-705(%rip) + WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 _vsigned: BYTE $0x55 // pushq %rbp @@ -5720,71 +5006,72 @@ _vsigned: WORD $0x8b48; BYTE $0x0e // movq (%rsi), %rcx LONG $0x184a8948 // movq %rcx, $24(%rdx) WORD $0x394c; BYTE $0xd8 // cmpq %r11, %rax - LONG $0x0046830f; WORD $0x0000 // jae LBB20_1, $70(%rip) - LONG $0x0cb60f41; BYTE $0x01 // movzbl (%r9,%rax), %ecx + LONG $0x0044830f; WORD $0x0000 // jae LBB15_1, $68(%rip) + LONG $0x010c8a41 // movb (%r9,%rax), %cl LONG $0x0001b841; WORD $0x0000 // movl $1, %r8d WORD $0xf980; BYTE $0x2d // cmpb $45, %cl - LONG $0x0018850f; WORD $0x0000 // jne LBB20_5, $24(%rip) + LONG $0x0017850f; WORD $0x0000 // jne LBB15_5, $23(%rip) WORD $0xff48; BYTE $0xc0 // incq %rax WORD $0x394c; BYTE $0xd8 // cmpq %r11, %rax - LONG $0x0026830f; WORD $0x0000 // jae LBB20_1, $38(%rip) - LONG $0x0cb60f41; BYTE $0x01 // movzbl (%r9,%rax), %ecx + LONG $0x0025830f; WORD $0x0000 // jae LBB15_1, $37(%rip) + LONG $0x010c8a41 // movb (%r9,%rax), %cl LONG $0xffc0c749; WORD $0xffff; BYTE $0xff // movq $-1, %r8 -LBB20_5: - WORD $0x798d; BYTE $0xc6 // leal $-58(%rcx), %edi - LONG $0xf5ff8040 // cmpb $-11, %dil - LONG $0x001a870f; WORD $0x0000 // ja LBB20_7, $26(%rip) +LBB15_5: + WORD $0x798d; BYTE $0xd0 // leal $-48(%rcx), %edi + LONG $0x0aff8040 // cmpb $10, %dil + LONG $0x001a820f; WORD $0x0000 // jb LBB15_7, $26(%rip) WORD $0x8948; BYTE $0x06 // movq %rax, (%rsi) LONG $0xfe02c748; WORD $0xffff; BYTE $0xff // movq $-2, (%rdx) BYTE $0x5b // popq %rbx BYTE $0x5d // popq %rbp BYTE $0xc3 // retq -LBB20_1: +LBB15_1: WORD $0x894c; BYTE $0x1e // movq %r11, (%rsi) LONG $0xff02c748; WORD $0xffff; BYTE $0xff // movq $-1, (%rdx) BYTE $0x5b // popq %rbx BYTE $0x5d // popq %rbp BYTE $0xc3 // retq -LBB20_7: +LBB15_7: WORD $0xf980; BYTE $0x30 // cmpb $48, %cl - LONG $0x0032850f; WORD $0x0000 // jne LBB20_12, $50(%rip) - LONG $0x01508d4c // leaq $1(%rax), %r10 + LONG $0x0035850f; WORD $0x0000 // jne LBB15_12, $53(%rip) + LONG $0x01788d48 // leaq $1(%rax), %rdi WORD $0x394c; BYTE $0xd8 // cmpq %r11, %rax - LONG $0x007f830f; WORD $0x0000 // jae LBB20_11, $127(%rip) - LONG $0x3cb60f43; BYTE $0x11 // movzbl (%r9,%r10), %edi - WORD $0xc783; BYTE $0xd2 // addl $-46, %edi - WORD $0xff83; BYTE $0x37 // cmpl $55, %edi - LONG $0x006e870f; WORD $0x0000 // ja LBB20_11, $110(%rip) + LONG $0x0081830f; WORD $0x0000 // jae LBB15_11, $129(%rip) + LONG $0x390c8a41 // movb (%r9,%rdi), %cl + WORD $0xc180; BYTE $0xd2 // addb $-46, %cl + WORD $0xf980; BYTE $0x37 // cmpb $55, %cl + LONG $0x0071870f; WORD $0x0000 // ja LBB15_11, $113(%rip) + LONG $0xd1b60f44 // movzbl %cl, %r10d QUAD $0x000000800001b948; WORD $0x0080 // movabsq $36028797027352577, %rcx - LONG $0xf9a30f48 // btq %rdi, %rcx - LONG $0x005a830f; WORD $0x0000 // jae LBB20_11, $90(%rip) + LONG $0xd1a30f4c // btq %r10, %rcx + LONG $0x0059830f; WORD $0x0000 // jae LBB15_11, $89(%rip) -LBB20_12: - WORD $0x394c; BYTE $0xd8 // cmpq %r11, %rax - WORD $0x894d; BYTE $0xda // movq %r11, %r10 - LONG $0xd0470f4c // cmovaq %rax, %r10 - WORD $0xc931 // xorl %ecx, %ecx - LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 - -LBB20_13: +LBB15_12: WORD $0x394c; BYTE $0xd8 // cmpq %r11, %rax - LONG $0x007d830f; WORD $0x0000 // jae LBB20_23, $125(%rip) + WORD $0x894d; BYTE $0xda // movq %r11, %r10 + LONG $0xd0470f4c // cmovaq %rax, %r10 + WORD $0xc931 // xorl %ecx, %ecx + LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 + +LBB15_13: + WORD $0x3949; BYTE $0xc2 // cmpq %rax, %r10 + LONG $0x007f840f; WORD $0x0000 // je LBB15_23, $127(%rip) LONG $0x3cbe0f49; BYTE $0x01 // movsbq (%r9,%rax), %rdi WORD $0x5f8d; BYTE $0xd0 // leal $-48(%rdi), %ebx WORD $0xfb80; BYTE $0x09 // cmpb $9, %bl - LONG $0x0033870f; WORD $0x0000 // ja LBB20_18, $51(%rip) + LONG $0x0033870f; WORD $0x0000 // ja LBB15_18, $51(%rip) LONG $0x0ac96b48 // imulq $10, %rcx, %rcx - LONG $0x0013800f; WORD $0x0000 // jo LBB20_17, $19(%rip) + LONG $0x0013800f; WORD $0x0000 // jo LBB15_17, $19(%rip) WORD $0xff48; BYTE $0xc0 // incq %rax WORD $0xc783; BYTE $0xd0 // addl $-48, %edi LONG $0xf8af0f49 // imulq %r8, %rdi WORD $0x0148; BYTE $0xf9 // addq %rdi, %rcx - LONG $0xffc9810f; WORD $0xffff // jno LBB20_13, $-55(%rip) + LONG $0xffc9810f; WORD $0xffff // jno LBB15_13, $-55(%rip) -LBB20_17: +LBB15_17: WORD $0xff48; BYTE $0xc8 // decq %rax WORD $0x8948; BYTE $0x06 // movq %rax, (%rsi) LONG $0xfb02c748; WORD $0xffff; BYTE $0xff // movq $-5, (%rdx) @@ -5792,169 +5079,160 @@ LBB20_17: BYTE $0x5d // popq %rbp BYTE $0xc3 // retq -LBB20_11: - WORD $0x894c; BYTE $0x16 // movq %r10, (%rsi) +LBB15_11: + WORD $0x8948; BYTE $0x3e // movq %rdi, (%rsi) BYTE $0x5b // popq %rbx BYTE $0x5d // popq %rbp BYTE $0xc3 // retq -LBB20_18: +LBB15_18: WORD $0x394c; BYTE $0xd8 // cmpq %r11, %rax - LONG $0x002d830f; WORD $0x0000 // jae LBB20_22, $45(%rip) - LONG $0x3cb60f41; BYTE $0x01 // movzbl (%r9,%rax), %edi - WORD $0xff83; BYTE $0x2e // cmpl $46, %edi - LONG $0x0012840f; WORD $0x0000 // je LBB20_25, $18(%rip) - WORD $0xff83; BYTE $0x45 // cmpl $69, %edi - LONG $0x0009840f; WORD $0x0000 // je LBB20_25, $9(%rip) - WORD $0xff83; BYTE $0x65 // cmpl $101, %edi - LONG $0x000d850f; WORD $0x0000 // jne LBB20_22, $13(%rip) - -LBB20_25: + LONG $0x002f830f; WORD $0x0000 // jae LBB15_22, $47(%rip) + LONG $0x013c8a41 // movb (%r9,%rax), %dil + LONG $0x2eff8040 // cmpb $46, %dil + LONG $0x0014840f; WORD $0x0000 // je LBB15_25, $20(%rip) + LONG $0x45ff8040 // cmpb $69, %dil + LONG $0x000a840f; WORD $0x0000 // je LBB15_25, $10(%rip) + LONG $0x65ff8040 // cmpb $101, %dil + LONG $0x000d850f; WORD $0x0000 // jne LBB15_22, $13(%rip) + +LBB15_25: WORD $0x8948; BYTE $0x06 // movq %rax, (%rsi) LONG $0xfa02c748; WORD $0xffff; BYTE $0xff // movq $-6, (%rdx) BYTE $0x5b // popq %rbx BYTE $0x5d // popq %rbp BYTE $0xc3 // retq -LBB20_22: +LBB15_22: WORD $0x8949; BYTE $0xc2 // movq %rax, %r10 -LBB20_23: - WORD $0x894c; BYTE $0x16 // movq %r10, (%rsi) - LONG $0x104a8948 // movq %rcx, $16(%rdx) - BYTE $0x5b // popq %rbx - BYTE $0x5d // popq %rbp - BYTE $0xc3 // retq +LBB15_23: + WORD $0x894c; BYTE $0x16 // movq %r10, (%rsi) + LONG $0x104a8948 // movq %rcx, $16(%rdx) + BYTE $0x5b // popq %rbx + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 - // .p2align 4, 0x90 _vunsigned: BYTE $0x55 // pushq %rbp WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp - WORD $0x5641 // pushq %r14 BYTE $0x53 // pushq %rbx WORD $0x8949; BYTE $0xd0 // movq %rdx, %r8 WORD $0x8b48; BYTE $0x0e // movq (%rsi), %rcx WORD $0x8b4c; BYTE $0x0f // movq (%rdi), %r9 - LONG $0x08778b4c // movq $8(%rdi), %r14 + LONG $0x085f8b4c // movq $8(%rdi), %r11 LONG $0x0902c748; WORD $0x0000; BYTE $0x00 // movq $9, (%rdx) LONG $0xc057f8c5 // vxorps %xmm0, %xmm0, %xmm0 LONG $0x4211f8c5; BYTE $0x08 // vmovups %xmm0, $8(%rdx) WORD $0x8b48; BYTE $0x06 // movq (%rsi), %rax LONG $0x18428948 // movq %rax, $24(%rdx) - WORD $0x394c; BYTE $0xf1 // cmpq %r14, %rcx - LONG $0x001c830f; WORD $0x0000 // jae LBB21_1, $28(%rip) - LONG $0x04b60f41; BYTE $0x09 // movzbl (%r9,%rcx), %eax + WORD $0x394c; BYTE $0xd9 // cmpq %r11, %rcx + LONG $0x0019830f; WORD $0x0000 // jae LBB16_1, $25(%rip) + LONG $0x09048a41 // movb (%r9,%rcx), %al WORD $0x2d3c // cmpb $45, %al - LONG $0x001e850f; WORD $0x0000 // jne LBB21_4, $30(%rip) + LONG $0x001a850f; WORD $0x0000 // jne LBB16_4, $26(%rip) -LBB21_3: +LBB16_3: WORD $0x8948; BYTE $0x0e // movq %rcx, (%rsi) LONG $0xfa00c749; WORD $0xffff; BYTE $0xff // movq $-6, (%r8) BYTE $0x5b // popq %rbx - WORD $0x5e41 // popq %r14 BYTE $0x5d // popq %rbp BYTE $0xc3 // retq -LBB21_1: - WORD $0x894c; BYTE $0x36 // movq %r14, (%rsi) +LBB16_1: + WORD $0x894c; BYTE $0x1e // movq %r11, (%rsi) LONG $0xff00c749; WORD $0xffff; BYTE $0xff // movq $-1, (%r8) BYTE $0x5b // popq %rbx - WORD $0x5e41 // popq %r14 BYTE $0x5d // popq %rbp BYTE $0xc3 // retq -LBB21_4: - WORD $0x508d; BYTE $0xc6 // leal $-58(%rax), %edx - WORD $0xfa80; BYTE $0xf5 // cmpb $-11, %dl - LONG $0x000f870f; WORD $0x0000 // ja LBB21_6, $15(%rip) +LBB16_4: + WORD $0x508d; BYTE $0xd0 // leal $-48(%rax), %edx + WORD $0xfa80; BYTE $0x0a // cmpb $10, %dl + LONG $0x000d820f; WORD $0x0000 // jb LBB16_6, $13(%rip) WORD $0x8948; BYTE $0x0e // movq %rcx, (%rsi) LONG $0xfe00c749; WORD $0xffff; BYTE $0xff // movq $-2, (%r8) BYTE $0x5b // popq %rbx - WORD $0x5e41 // popq %r14 BYTE $0x5d // popq %rbp BYTE $0xc3 // retq -LBB21_6: +LBB16_6: WORD $0x303c // cmpb $48, %al - LONG $0x0026850f; WORD $0x0000 // jne LBB21_10, $38(%rip) - LONG $0x44b60f41; WORD $0x0109 // movzbl $1(%r9,%rcx), %eax - WORD $0xc083; BYTE $0xd2 // addl $-46, %eax - WORD $0xf883; BYTE $0x37 // cmpl $55, %eax - LONG $0x00c0870f; WORD $0x0000 // ja LBB21_9, $192(%rip) + LONG $0x0026850f; WORD $0x0000 // jne LBB16_7, $38(%rip) + LONG $0x09448a41; BYTE $0x01 // movb $1(%r9,%rcx), %al + WORD $0xd204 // addb $-46, %al + WORD $0x373c // cmpb $55, %al + LONG $0x00b6870f; WORD $0x0000 // ja LBB16_16, $182(%rip) + WORD $0xb60f; BYTE $0xc0 // movzbl %al, %eax QUAD $0x000000800001ba48; WORD $0x0080 // movabsq $36028797027352577, %rdx LONG $0xc2a30f48 // btq %rax, %rdx - LONG $0x00ac830f; WORD $0x0000 // jae LBB21_9, $172(%rip) + LONG $0x009f830f; WORD $0x0000 // jae LBB16_16, $159(%rip) -LBB21_10: - WORD $0x3949; BYTE $0xce // cmpq %rcx, %r14 - WORD $0x8949; BYTE $0xca // movq %rcx, %r10 - LONG $0xd6470f4d // cmovaq %r14, %r10 - WORD $0xc031 // xorl %eax, %eax - LONG $0x000abb41; WORD $0x0000 // movl $10, %r11d - LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 +LBB16_7: + WORD $0xc031 // xorl %eax, %eax + LONG $0x000aba41; WORD $0x0000 // movl $10, %r10d + QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90 -LBB21_11: - WORD $0x394c; BYTE $0xf1 // cmpq %r14, %rcx - LONG $0x007f830f; WORD $0x0000 // jae LBB21_22, $127(%rip) - LONG $0x1cbe0f41; BYTE $0x09 // movsbl (%r9,%rcx), %ebx - WORD $0x538d; BYTE $0xd0 // leal $-48(%rbx), %edx +LBB16_8: + WORD $0x3949; BYTE $0xcb // cmpq %rcx, %r11 + LONG $0x007b840f; WORD $0x0000 // je LBB16_22, $123(%rip) + LONG $0x3cbe0f41; BYTE $0x09 // movsbl (%r9,%rcx), %edi + WORD $0x578d; BYTE $0xd0 // leal $-48(%rdi), %edx WORD $0xfa80; BYTE $0x09 // cmpb $9, %dl - LONG $0x0042870f; WORD $0x0000 // ja LBB21_17, $66(%rip) - WORD $0xf749; BYTE $0xe3 // mulq %r11 - LONG $0x0027800f; WORD $0x0000 // jo LBB21_16, $39(%rip) + LONG $0x003f870f; WORD $0x0000 // ja LBB16_17, $63(%rip) + WORD $0xf749; BYTE $0xe2 // mulq %r10 + LONG $0x0026800f; WORD $0x0000 // jo LBB16_13, $38(%rip) WORD $0xff48; BYTE $0xc1 // incq %rcx - WORD $0xc383; BYTE $0xd0 // addl $-48, %ebx - WORD $0xff31 // xorl %edi, %edi - WORD $0x0148; BYTE $0xd8 // addq %rbx, %rax - LONG $0xc7920f40 // setb %dil - WORD $0x8948; BYTE $0xfa // movq %rdi, %rdx + WORD $0xc783; BYTE $0xd0 // addl $-48, %edi + WORD $0xdb31 // xorl %ebx, %ebx + WORD $0x0148; BYTE $0xf8 // addq %rdi, %rax + WORD $0x920f; BYTE $0xc3 // setb %bl + WORD $0x8948; BYTE $0xda // movq %rbx, %rdx WORD $0xf748; BYTE $0xda // negq %rdx - WORD $0x3148; BYTE $0xd7 // xorq %rdx, %rdi - LONG $0x0009850f; WORD $0x0000 // jne LBB21_16, $9(%rip) + WORD $0x3148; BYTE $0xd3 // xorq %rdx, %rbx + LONG $0x0009850f; WORD $0x0000 // jne LBB16_13, $9(%rip) WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx - LONG $0xffb6890f; WORD $0xffff // jns LBB21_11, $-74(%rip) + LONG $0xffb7890f; WORD $0xffff // jns LBB16_8, $-73(%rip) -LBB21_16: +LBB16_13: WORD $0xff48; BYTE $0xc9 // decq %rcx WORD $0x8948; BYTE $0x0e // movq %rcx, (%rsi) LONG $0xfb00c749; WORD $0xffff; BYTE $0xff // movq $-5, (%r8) BYTE $0x5b // popq %rbx - WORD $0x5e41 // popq %r14 BYTE $0x5d // popq %rbp BYTE $0xc3 // retq -LBB21_17: - WORD $0x394c; BYTE $0xf1 // cmpq %r14, %rcx - LONG $0x0020830f; WORD $0x0000 // jae LBB21_21, $32(%rip) - LONG $0x14b60f41; BYTE $0x09 // movzbl (%r9,%rcx), %edx - WORD $0xfa83; BYTE $0x2e // cmpl $46, %edx - LONG $0xff0e840f; WORD $0xffff // je LBB21_3, $-242(%rip) - WORD $0xfa83; BYTE $0x45 // cmpl $69, %edx - LONG $0xff05840f; WORD $0xffff // je LBB21_3, $-251(%rip) - WORD $0xfa83; BYTE $0x65 // cmpl $101, %edx - LONG $0xfefc840f; WORD $0xffff // je LBB21_3, $-260(%rip) - -LBB21_21: - WORD $0x8949; BYTE $0xca // movq %rcx, %r10 - -LBB21_22: - WORD $0x894c; BYTE $0x16 // movq %r10, (%rsi) +LBB16_17: + WORD $0x394c; BYTE $0xd9 // cmpq %r11, %rcx + LONG $0x001f830f; WORD $0x0000 // jae LBB16_21, $31(%rip) + LONG $0x09148a41 // movb (%r9,%rcx), %dl + WORD $0xfa80; BYTE $0x2e // cmpb $46, %dl + LONG $0xff1f840f; WORD $0xffff // je LBB16_3, $-225(%rip) + WORD $0xfa80; BYTE $0x45 // cmpb $69, %dl + LONG $0xff16840f; WORD $0xffff // je LBB16_3, $-234(%rip) + WORD $0xfa80; BYTE $0x65 // cmpb $101, %dl + LONG $0xff0d840f; WORD $0xffff // je LBB16_3, $-243(%rip) + +LBB16_21: + WORD $0x8949; BYTE $0xcb // movq %rcx, %r11 + +LBB16_22: + WORD $0x894c; BYTE $0x1e // movq %r11, (%rsi) LONG $0x10408949 // movq %rax, $16(%r8) BYTE $0x5b // popq %rbx - WORD $0x5e41 // popq %r14 BYTE $0x5d // popq %rbp BYTE $0xc3 // retq -LBB21_9: - WORD $0xff48; BYTE $0xc1 // incq %rcx - WORD $0x8948; BYTE $0x0e // movq %rcx, (%rsi) - BYTE $0x5b // popq %rbx - WORD $0x5e41 // popq %r14 - BYTE $0x5d // popq %rbp - BYTE $0xc3 // retq - BYTE $0x00 // .p2align 4, 0x00 +LBB16_16: + WORD $0xff48; BYTE $0xc1 // incq %rcx + WORD $0x8948; BYTE $0x0e // movq %rcx, (%rsi) + BYTE $0x5b // popq %rbx + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + QUAD $0x0000000000000000; BYTE $0x00 // .p2align 4, 0x00 -LCPI22_0: +LCPI17_0: QUAD $0x0000000000000001 // .quad 1 QUAD $0x0000000000000005 // .quad 5 @@ -5965,7 +5243,7 @@ _skip_array: WORD $0x8948; BYTE $0xd0 // movq %rdx, %rax WORD $0x8948; BYTE $0xf2 // movq %rsi, %rdx WORD $0x8948; BYTE $0xfe // movq %rdi, %rsi - QUAD $0xffffffdb0528f8c5 // vmovaps $-37(%rip), %xmm0 /* LCPI22_0(%rip) */ + QUAD $0xffffffdb0528f8c5 // vmovaps $-37(%rip), %xmm0 /* LCPI17_0(%rip) */ LONG $0x0011f8c5 // vmovups %xmm0, (%rax) WORD $0x8948; BYTE $0xc7 // movq %rax, %rdi BYTE $0x5d // popq %rbp @@ -5983,294 +5261,394 @@ _fsm_exec: LONG $0x28ec8348 // subq $40, %rsp LONG $0xb84d8948 // movq %rcx, $-72(%rbp) LONG $0x003f8348 // cmpq $0, (%rdi) - LONG $0x03b1840f; WORD $0x0000 // je LBB23_2, $945(%rip) - WORD $0x8949; BYTE $0xd4 // movq %rdx, %r12 - WORD $0x8949; BYTE $0xff // movq %rdi, %r15 - LONG $0xd0758948 // movq %rsi, $-48(%rbp) + LONG $0x0591840f; WORD $0x0000 // je LBB18_76, $1425(%rip) + WORD $0x8949; BYTE $0xd0 // movq %rdx, %r8 + WORD $0x8949; BYTE $0xfc // movq %rdi, %r12 + LONG $0x08468d48 // leaq $8(%rsi), %rax + LONG $0xd0458948 // movq %rax, $-48(%rbp) LONG $0xffc6c749; WORD $0xffff; BYTE $0xff // movq $-1, %r14 - LONG $0xc8558948 // movq %rdx, $-56(%rbp) - LONG $0x000033e9; BYTE $0x00 // jmp LBB23_7, $51(%rip) - -LBB23_3: - WORD $0x8b49; BYTE $0x0f // movq (%r15), %rcx - LONG $0x000006b8; BYTE $0x00 // movl $6, %eax - LONG $0xfff98148; WORD $0x000f; BYTE $0x00 // cmpq $4095, %rcx - LONG $0x03a78f0f; WORD $0x0000 // jg LBB23_62, $935(%rip) - WORD $0x9090 // .p2align 4, 0x90 + QUAD $0x000100002600bb49; WORD $0x0000 // movabsq $4294977024, %r11 + LONG $0xc0758948 // movq %rsi, $-64(%rbp) + LONG $0x000029e9; BYTE $0x00 // jmp LBB18_3, $41(%rip) -LBB23_4: - LONG $0x01518d48 // leaq $1(%rcx), %rdx - WORD $0x8949; BYTE $0x17 // movq %rdx, (%r15) - WORD $0x8948; BYTE $0xca // movq %rcx, %rdx +LBB18_2: + LONG $0x03488d48 // leaq $3(%rax), %rcx + WORD $0x8949; BYTE $0x08 // movq %rcx, (%r8) + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0x05a98e0f; WORD $0x0000 // jle LBB18_83, $1449(%rip) + QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90 -LBB23_5: - LONG $0xd7448949; BYTE $0x08 // movq %rax, $8(%r15,%rdx,8) +LBB18_61: + LONG $0x24148b4d // movq (%r12), %r10 + WORD $0x894d; BYTE $0xf7 // movq %r14, %r15 + WORD $0x854d; BYTE $0xd2 // testq %r10, %r10 + LONG $0x0547840f; WORD $0x0000 // je LBB18_77, $1351(%rip) -LBB23_6: - LONG $0x003f8349 // cmpq $0, (%r15) - WORD $0x894c; BYTE $0xf0 // movq %r14, %rax - LONG $0x035c840f; WORD $0x0000 // je LBB23_54, $860(%rip) +LBB18_3: + WORD $0x894d; BYTE $0xf1 // movq %r14, %r9 + WORD $0x8b48; BYTE $0x3e // movq (%rsi), %rdi + LONG $0x084e8b48 // movq $8(%rsi), %rcx + WORD $0x8b49; BYTE $0x00 // movq (%r8), %rax + WORD $0x8948; BYTE $0xc2 // movq %rax, %rdx + WORD $0x2948; BYTE $0xca // subq %rcx, %rdx + LONG $0x0037830f; WORD $0x0000 // jae LBB18_8, $55(%rip) + WORD $0x1c8a; BYTE $0x07 // movb (%rdi,%rax), %bl + WORD $0xfb80; BYTE $0x0d // cmpb $13, %bl + LONG $0x002b840f; WORD $0x0000 // je LBB18_8, $43(%rip) + WORD $0xfb80; BYTE $0x20 // cmpb $32, %bl + LONG $0x0022840f; WORD $0x0000 // je LBB18_8, $34(%rip) + WORD $0xc380; BYTE $0xf7 // addb $-9, %bl + WORD $0xfb80; BYTE $0x01 // cmpb $1, %bl + LONG $0x0016860f; WORD $0x0000 // jbe LBB18_8, $22(%rip) + WORD $0x8949; BYTE $0xc6 // movq %rax, %r14 + LONG $0x000130e9; BYTE $0x00 // jmp LBB18_29, $304(%rip) + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 -LBB23_7: - LONG $0xd06d8b4c // movq $-48(%rbp), %r13 - LONG $0x007d8b49 // movq (%r13), %rdi - LONG $0x08758b49 // movq $8(%r13), %rsi - WORD $0x894c; BYTE $0xe2 // movq %r12, %rdx - LONG $0xffee60e8; BYTE $0xff // callq _advance_ns, $-4512(%rip) - WORD $0xc084 // testb %al, %al - LONG $0x0348840f; WORD $0x0000 // je LBB23_2, $840(%rip) - LONG $0xfffe8349 // cmpq $-1, %r14 - LONG $0x0007850f; WORD $0x0000 // jne LBB23_10, $7(%rip) - LONG $0x24348b4d // movq (%r12), %r14 - WORD $0xff49; BYTE $0xce // decq %r14 +LBB18_8: + LONG $0x01708d4c // leaq $1(%rax), %r14 + WORD $0x3949; BYTE $0xce // cmpq %rcx, %r14 + LONG $0x0023830f; WORD $0x0000 // jae LBB18_12, $35(%rip) + LONG $0x371c8a42 // movb (%rdi,%r14), %bl + WORD $0xfb80; BYTE $0x0d // cmpb $13, %bl + LONG $0x0016840f; WORD $0x0000 // je LBB18_12, $22(%rip) + WORD $0xfb80; BYTE $0x20 // cmpb $32, %bl + LONG $0x000d840f; WORD $0x0000 // je LBB18_12, $13(%rip) + WORD $0xc380; BYTE $0xf7 // addb $-9, %bl + WORD $0xfb80; BYTE $0x01 // cmpb $1, %bl + LONG $0x00f3870f; WORD $0x0000 // ja LBB18_29, $243(%rip) + BYTE $0x90 // .p2align 4, 0x90 -LBB23_10: - WORD $0xbe0f; BYTE $0xf0 // movsbl %al, %esi - WORD $0x8b49; BYTE $0x0f // movq (%r15), %rcx - LONG $0xff518d48 // leaq $-1(%rcx), %rdx - LONG $0xcf3c8b41 // movl (%r15,%rcx,8), %edi - WORD $0xcfff // decl %edi - WORD $0xff83; BYTE $0x05 // cmpl $5, %edi - LONG $0x0027870f; WORD $0x0000 // ja LBB23_14, $39(%rip) - LONG $0x7b1d8d48; WORD $0x0004; BYTE $0x00 // leaq $1147(%rip), %rbx /* LJTI23_0(%rip) */ - LONG $0xbb3c6348 // movslq (%rbx,%rdi,4), %rdi - WORD $0x0148; BYTE $0xdf // addq %rbx, %rdi - JMP DI - -LBB23_12: - WORD $0xfe83; BYTE $0x2c // cmpl $44, %esi - LONG $0x01a8840f; WORD $0x0000 // je LBB23_35, $424(%rip) - WORD $0xfe83; BYTE $0x5d // cmpl $93, %esi - LONG $0x016c840f; WORD $0x0000 // je LBB23_32, $364(%rip) - LONG $0x000310e9; BYTE $0x00 // jmp LBB23_58, $784(%rip) - -LBB23_14: - WORD $0x8949; BYTE $0x17 // movq %rdx, (%r15) - LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq $-2, %rax - WORD $0xfe83; BYTE $0x7b // cmpl $123, %esi - LONG $0x0099860f; WORD $0x0000 // jbe LBB23_26, $153(%rip) - LONG $0x0002d7e9; BYTE $0x00 // jmp LBB23_54, $727(%rip) - -LBB23_15: - WORD $0xfe83; BYTE $0x7d // cmpl $125, %esi - LONG $0x0146840f; WORD $0x0000 // je LBB23_32, $326(%rip) - WORD $0xfe83; BYTE $0x2c // cmpl $44, %esi - LONG $0x02e6850f; WORD $0x0000 // jne LBB23_58, $742(%rip) - LONG $0x000003b8; BYTE $0x00 // movl $3, %eax - LONG $0xfff98148; WORD $0x000f; BYTE $0x00 // cmpq $4095, %rcx - LONG $0xff3b8e0f; WORD $0xffff // jle LBB23_4, $-197(%rip) - LONG $0x0002dbe9; BYTE $0x00 // jmp LBB23_62, $731(%rip) - -LBB23_18: - WORD $0x223c // cmpb $34, %al - LONG $0x02c7850f; WORD $0x0000 // jne LBB23_58, $711(%rip) - QUAD $0x00000004cf04c749 // movq $4, (%r15,%rcx,8) - LONG $0x241c8b49 // movq (%r12), %rbx - WORD $0x894c; BYTE $0xef // movq %r13, %rdi - -LBB23_20: - WORD $0x8948; BYTE $0xde // movq %rbx, %rsi - LONG $0xc0558d48 // leaq $-64(%rbp), %rdx - LONG $0xb84d8b48 // movq $-72(%rbp), %rcx - LONG $0xfff0bfe8; BYTE $0xff // callq _advance_string, $-3905(%rip) - WORD $0x8949; BYTE $0xc5 // movq %rax, %r13 - WORD $0x8548; BYTE $0xc0 // testq %rax, %rax - LONG $0x0107890f; WORD $0x0000 // jns LBB23_33, $263(%rip) - LONG $0xc0458b48 // movq $-64(%rbp), %rax - LONG $0x000107e9; BYTE $0x00 // jmp LBB23_34, $263(%rip) +LBB18_12: + LONG $0x02708d4c // leaq $2(%rax), %r14 + WORD $0x3949; BYTE $0xce // cmpq %rcx, %r14 + LONG $0x0023830f; WORD $0x0000 // jae LBB18_16, $35(%rip) + LONG $0x371c8a42 // movb (%rdi,%r14), %bl + WORD $0xfb80; BYTE $0x0d // cmpb $13, %bl + LONG $0x0016840f; WORD $0x0000 // je LBB18_16, $22(%rip) + WORD $0xfb80; BYTE $0x20 // cmpb $32, %bl + LONG $0x000d840f; WORD $0x0000 // je LBB18_16, $13(%rip) + WORD $0xc380; BYTE $0xf7 // addb $-9, %bl + WORD $0xfb80; BYTE $0x01 // cmpb $1, %bl + LONG $0x00c3870f; WORD $0x0000 // ja LBB18_29, $195(%rip) + BYTE $0x90 // .p2align 4, 0x90 -LBB23_22: - WORD $0x3a3c // cmpb $58, %al - LONG $0x028b850f; WORD $0x0000 // jne LBB23_58, $651(%rip) - WORD $0xc031 // xorl %eax, %eax - LONG $0xfffef5e9; BYTE $0xff // jmp LBB23_5, $-267(%rip) +LBB18_16: + LONG $0x03708d4c // leaq $3(%rax), %r14 + WORD $0x3949; BYTE $0xce // cmpq %rcx, %r14 + LONG $0x0023830f; WORD $0x0000 // jae LBB18_20, $35(%rip) + LONG $0x371c8a42 // movb (%rdi,%r14), %bl + WORD $0xfb80; BYTE $0x0d // cmpb $13, %bl + LONG $0x0016840f; WORD $0x0000 // je LBB18_20, $22(%rip) + WORD $0xfb80; BYTE $0x20 // cmpb $32, %bl + LONG $0x000d840f; WORD $0x0000 // je LBB18_20, $13(%rip) + WORD $0xc380; BYTE $0xf7 // addb $-9, %bl + WORD $0xfb80; BYTE $0x01 // cmpb $1, %bl + LONG $0x0093870f; WORD $0x0000 // ja LBB18_29, $147(%rip) + BYTE $0x90 // .p2align 4, 0x90 -LBB23_24: - WORD $0x5d3c // cmpb $93, %al - LONG $0x00d3840f; WORD $0x0000 // je LBB23_32, $211(%rip) - QUAD $0x00000001cf04c749 // movq $1, (%r15,%rcx,8) - LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq $-2, %rax - WORD $0xfe83; BYTE $0x7b // cmpl $123, %esi - LONG $0x0243870f; WORD $0x0000 // ja LBB23_54, $579(%rip) +LBB18_20: + LONG $0x04588d48 // leaq $4(%rax), %rbx + WORD $0x3948; BYTE $0xd9 // cmpq %rbx, %rcx + LONG $0x0450860f; WORD $0x0000 // jbe LBB18_75, $1104(%rip) + WORD $0x3948; BYTE $0xd9 // cmpq %rbx, %rcx + LONG $0x004a840f; WORD $0x0000 // je LBB18_26, $74(%rip) + LONG $0x0f1c8d48 // leaq (%rdi,%rcx), %rbx + LONG $0x04c28348 // addq $4, %rdx + LONG $0x07748d4c; BYTE $0x05 // leaq $5(%rdi,%rax), %r14 + QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 -LBB23_26: - WORD $0xf189 // movl %esi, %ecx - LONG $0xbe158d48; WORD $0x0003; BYTE $0x00 // leaq $958(%rip), %rdx /* LJTI23_1(%rip) */ - LONG $0x8a0c6348 // movslq (%rdx,%rcx,4), %rcx - WORD $0x0148; BYTE $0xd1 // addq %rdx, %rcx - LONG $0xffc5c749; WORD $0xffff; BYTE $0xff // movq $-1, %r13 - JMP CX +LBB18_23: + LONG $0x46be0f41; BYTE $0xff // movsbl $-1(%r14), %eax + WORD $0xf883; BYTE $0x20 // cmpl $32, %eax + LONG $0x0042870f; WORD $0x0000 // ja LBB18_28, $66(%rip) + LONG $0xc3a30f49 // btq %rax, %r11 + LONG $0x0038830f; WORD $0x0000 // jae LBB18_28, $56(%rip) + WORD $0xff49; BYTE $0xc6 // incq %r14 + WORD $0xff48; BYTE $0xc2 // incq %rdx + LONG $0xffdc850f; WORD $0xffff // jne LBB18_23, $-36(%rip) + LONG $0x00000ae9; BYTE $0x00 // jmp LBB18_27, $10(%rip) + LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 -LBB23_27: - LONG $0xc8458b48 // movq $-56(%rbp), %rax - WORD $0x8b48; BYTE $0x18 // movq (%rax), %rbx - LONG $0xff6b8d4c // leaq $-1(%rbx), %r13 +LBB18_26: + WORD $0x0148; BYTE $0xfb // addq %rdi, %rbx + +LBB18_27: + WORD $0x2948; BYTE $0xfb // subq %rdi, %rbx + WORD $0x8949; BYTE $0xde // movq %rbx, %r14 + WORD $0x3949; BYTE $0xce // cmpq %rcx, %r14 + LONG $0x0020820f; WORD $0x0000 // jb LBB18_29, $32(%rip) + LONG $0x0003e9e9; BYTE $0x00 // jmp LBB18_76, $1001(%rip) + QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB18_28: + WORD $0x8948; BYTE $0xfa // movq %rdi, %rdx + WORD $0xf748; BYTE $0xd2 // notq %rdx + WORD $0x0149; BYTE $0xd6 // addq %rdx, %r14 + WORD $0x3949; BYTE $0xce // cmpq %rcx, %r14 + LONG $0x03ce830f; WORD $0x0000 // jae LBB18_76, $974(%rip) + +LBB18_29: + LONG $0x014e8d49 // leaq $1(%r14), %rcx + WORD $0x8949; BYTE $0x08 // movq %rcx, (%r8) + LONG $0x0cbe0f42; BYTE $0x37 // movsbl (%rdi,%r14), %ecx + LONG $0xffc7c749; WORD $0xffff; BYTE $0xff // movq $-1, %r15 + WORD $0xc985 // testl %ecx, %ecx + LONG $0x03ba840f; WORD $0x0000 // je LBB18_77, $954(%rip) + LONG $0x242c8b4d // movq (%r12), %r13 + LONG $0xff558d4d // leaq $-1(%r13), %r10 + LONG $0xec1c8b43 // movl (%r12,%r13,8), %ebx + LONG $0xfff98349 // cmpq $-1, %r9 + LONG $0xf1450f4d // cmovneq %r9, %r14 + WORD $0xcbff // decl %ebx + WORD $0xfb83; BYTE $0x05 // cmpl $5, %ebx + LONG $0x0037870f; WORD $0x0000 // ja LBB18_35, $55(%rip) + LONG $0xfd158d48; WORD $0x0004; BYTE $0x00 // leaq $1277(%rip), %rdx /* LJTI18_0(%rip) */ + LONG $0x9a046348 // movslq (%rdx,%rbx,4), %rax + WORD $0x0148; BYTE $0xd0 // addq %rdx, %rax + JMP AX + +LBB18_32: + WORD $0xf983; BYTE $0x2c // cmpl $44, %ecx + LONG $0x0199840f; WORD $0x0000 // je LBB18_53, $409(%rip) + WORD $0xf983; BYTE $0x5d // cmpl $93, %ecx + LONG $0x03d6850f; WORD $0x0000 // jne LBB18_85, $982(%rip) + LONG $0x2414894d // movq %r10, (%r12) + WORD $0x894d; BYTE $0xf7 // movq %r14, %r15 + WORD $0x854d; BYTE $0xd2 // testq %r10, %r10 + LONG $0xfe22850f; WORD $0xffff // jne LBB18_3, $-478(%rip) + LONG $0x000364e9; BYTE $0x00 // jmp LBB18_77, $868(%rip) + +LBB18_35: + LONG $0x2414894d // movq %r10, (%r12) + WORD $0xf983; BYTE $0x7b // cmpl $123, %ecx + LONG $0x00f8860f; WORD $0x0000 // jbe LBB18_51, $248(%rip) + LONG $0x0003afe9; BYTE $0x00 // jmp LBB18_85, $943(%rip) + +LBB18_36: + WORD $0xf983; BYTE $0x2c // cmpl $44, %ecx + LONG $0x0183840f; WORD $0x0000 // je LBB18_55, $387(%rip) + WORD $0xf983; BYTE $0x7d // cmpl $125, %ecx + LONG $0x039d850f; WORD $0x0000 // jne LBB18_85, $925(%rip) + LONG $0x2414894d // movq %r10, (%r12) + WORD $0x894d; BYTE $0xf7 // movq %r14, %r15 + WORD $0x854d; BYTE $0xd2 // testq %r10, %r10 + LONG $0xfde9850f; WORD $0xffff // jne LBB18_3, $-535(%rip) + LONG $0x00032be9; BYTE $0x00 // jmp LBB18_77, $811(%rip) + +LBB18_39: + WORD $0xf980; BYTE $0x22 // cmpb $34, %cl + LONG $0x037f850f; WORD $0x0000 // jne LBB18_85, $895(%rip) + QUAD $0x00000004ec04c74b // movq $4, (%r12,%r13,8) + +LBB18_41: + QUAD $0xffffffffc845c748 // movq $-1, $-56(%rbp) + WORD $0x8b4d; BYTE $0x28 // movq (%r8), %r13 + WORD $0x8948; BYTE $0xf7 // movq %rsi, %rdi + WORD $0x894c; BYTE $0xee // movq %r13, %rsi + LONG $0xc8558d48 // leaq $-56(%rbp), %rdx + LONG $0xb84d8b48 // movq $-72(%rbp), %rcx + WORD $0x894c; BYTE $0xc3 // movq %r8, %rbx + LONG $0xffee92e8; BYTE $0xff // callq _advance_string, $-4462(%rip) + WORD $0x8949; BYTE $0xc7 // movq %rax, %r15 + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0x030b880f; WORD $0x0000 // js LBB18_78, $779(%rip) + WORD $0x894c; BYTE $0x3b // movq %r15, (%rbx) + WORD $0x854d; BYTE $0xed // testq %r13, %r13 + WORD $0x8949; BYTE $0xd8 // movq %rbx, %r8 + LONG $0xc0758b48 // movq $-64(%rbp), %rsi + QUAD $0x000100002600bb49; WORD $0x0000 // movabsq $4294977024, %r11 + LONG $0xfd798f0f; WORD $0xffff // jg LBB18_61, $-647(%rip) + LONG $0x000301e9; BYTE $0x00 // jmp LBB18_79, $769(%rip) + +LBB18_43: + WORD $0xf980; BYTE $0x3a // cmpb $58, %cl + LONG $0x031f850f; WORD $0x0000 // jne LBB18_85, $799(%rip) + QUAD $0x00000000ec04c74b // movq $0, (%r12,%r13,8) + LONG $0xfffd5ee9; BYTE $0xff // jmp LBB18_61, $-674(%rip) + +LBB18_45: + WORD $0xf980; BYTE $0x5d // cmpb $93, %cl + LONG $0x003c850f; WORD $0x0000 // jne LBB18_50, $60(%rip) + LONG $0x2414894d // movq %r10, (%r12) + WORD $0x894d; BYTE $0xf7 // movq %r14, %r15 + WORD $0x854d; BYTE $0xd2 // testq %r10, %r10 + LONG $0xfd55850f; WORD $0xffff // jne LBB18_3, $-683(%rip) + LONG $0x000297e9; BYTE $0x00 // jmp LBB18_77, $663(%rip) + +LBB18_47: + WORD $0xf983; BYTE $0x22 // cmpl $34, %ecx + LONG $0x00eb840f; WORD $0x0000 // je LBB18_57, $235(%rip) + WORD $0xf983; BYTE $0x7d // cmpl $125, %ecx + LONG $0x02e2850f; WORD $0x0000 // jne LBB18_85, $738(%rip) + LONG $0x2414894d // movq %r10, (%r12) + WORD $0x894d; BYTE $0xf7 // movq %r14, %r15 + WORD $0x854d; BYTE $0xd2 // testq %r10, %r10 + LONG $0xfd2e850f; WORD $0xffff // jne LBB18_3, $-722(%rip) + LONG $0x000270e9; BYTE $0x00 // jmp LBB18_77, $624(%rip) + +LBB18_50: + QUAD $0x00000001ec04c74b // movq $1, (%r12,%r13,8) + WORD $0xf983; BYTE $0x7b // cmpl $123, %ecx + LONG $0x02bc870f; WORD $0x0000 // ja LBB18_85, $700(%rip) + +LBB18_51: + WORD $0xc889 // movl %ecx, %eax + LONG $0xd70d8d48; WORD $0x0003; BYTE $0x00 // leaq $983(%rip), %rcx /* LJTI18_1(%rip) */ + LONG $0x81046348 // movslq (%rcx,%rax,4), %rax + WORD $0x0148; BYTE $0xc8 // addq %rcx, %rax + JMP AX + +LBB18_52: + WORD $0x8b49; BYTE $0x18 // movq (%r8), %rbx + LONG $0xff7b8d4c // leaq $-1(%rbx), %r15 + LONG $0x1f7c8d48; BYTE $0xff // leaq $-1(%rdi,%rbx), %rdi LONG $0xd0458b48 // movq $-48(%rbp), %rax - WORD $0x8b48; BYTE $0x38 // movq (%rax), %rdi - WORD $0x014c; BYTE $0xef // addq %r13, %rdi - LONG $0x08708b48 // movq $8(%rax), %rsi - WORD $0x294c; BYTE $0xee // subq %r13, %rsi - LONG $0x0006e1e8; BYTE $0x00 // callq _do_skip_number, $1761(%rip) + WORD $0x8b48; BYTE $0x30 // movq (%rax), %rsi + WORD $0x294c; BYTE $0xfe // subq %r15, %rsi + WORD $0x894d; BYTE $0xc5 // movq %r8, %r13 + LONG $0x000728e8; BYTE $0x00 // callq _do_skip_number, $1832(%rip) + QUAD $0x000100002600bb49; WORD $0x0000 // movabsq $4294977024, %r11 + LONG $0xc0758b48 // movq $-64(%rbp), %rsi + WORD $0x894d; BYTE $0xe8 // movq %r13, %r8 LONG $0xff488d48 // leaq $-1(%rax), %rcx LONG $0xfec2c748; WORD $0xffff; BYTE $0xff // movq $-2, %rdx WORD $0x2948; BYTE $0xc2 // subq %rax, %rdx WORD $0x8548; BYTE $0xc0 // testq %rax, %rax LONG $0xd1490f48 // cmovnsq %rcx, %rdx LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq $-2, %rax - LONG $0xe8480f4c // cmovsq %rax, %r13 + LONG $0xf8480f4c // cmovsq %rax, %r15 WORD $0x0148; BYTE $0xda // addq %rbx, %rdx - LONG $0xc8658b4c // movq $-56(%rbp), %r12 - LONG $0x24148949 // movq %rdx, (%r12) - WORD $0x854d; BYTE $0xed // testq %r13, %r13 - LONG $0xfe6c890f; WORD $0xffff // jns LBB23_6, $-404(%rip) - LONG $0x0001dfe9; BYTE $0x00 // jmp LBB23_55, $479(%rip) - -LBB23_28: - WORD $0xfe83; BYTE $0x7d // cmpl $125, %esi - LONG $0x003f840f; WORD $0x0000 // je LBB23_32, $63(%rip) - WORD $0xfe83; BYTE $0x22 // cmpl $34, %esi - LONG $0x01df850f; WORD $0x0000 // jne LBB23_58, $479(%rip) - QUAD $0x00000002cf04c749 // movq $2, (%r15,%rcx,8) - LONG $0x241c8b49 // movq (%r12), %rbx - WORD $0x894c; BYTE $0xef // movq %r13, %rdi - WORD $0x8948; BYTE $0xde // movq %rbx, %rsi - LONG $0xc0558d48 // leaq $-64(%rbp), %rdx - LONG $0xb84d8b48 // movq $-72(%rbp), %rcx - LONG $0xffefd7e8; BYTE $0xff // callq _advance_string, $-4137(%rip) - WORD $0x8949; BYTE $0xc5 // movq %rax, %r13 - WORD $0x8548; BYTE $0xc0 // testq %rax, %rax - LONG $0x0052890f; WORD $0x0000 // jns LBB23_37, $82(%rip) - LONG $0xc0458b48 // movq $-64(%rbp), %rax - LONG $0x000052e9; BYTE $0x00 // jmp LBB23_38, $82(%rip) - WORD $0x9090 // .p2align 4, 0x90 - -LBB23_32: - WORD $0x8949; BYTE $0x17 // movq %rdx, (%r15) - WORD $0x894d; BYTE $0xf5 // movq %r14, %r13 - WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx - LONG $0xfe1d850f; WORD $0xffff // jne LBB23_7, $-483(%rip) - LONG $0x000183e9; BYTE $0x00 // jmp LBB23_55, $387(%rip) - -LBB23_33: - WORD $0xff48; BYTE $0xcb // decq %rbx - WORD $0x894c; BYTE $0xe8 // movq %r13, %rax - WORD $0x8949; BYTE $0xdd // movq %rbx, %r13 - -LBB23_34: - LONG $0xc8658b4c // movq $-56(%rbp), %r12 - LONG $0x24048949 // movq %rax, (%r12) - WORD $0x854d; BYTE $0xed // testq %r13, %r13 - LONG $0xfdf1890f; WORD $0xffff // jns LBB23_6, $-527(%rip) - LONG $0x000164e9; BYTE $0x00 // jmp LBB23_55, $356(%rip) - -LBB23_35: - LONG $0xfff98148; WORD $0x000f; BYTE $0x00 // cmpq $4095, %rcx - LONG $0x01758f0f; WORD $0x0000 // jg LBB23_62, $373(%rip) - WORD $0xc031 // xorl %eax, %eax - LONG $0xfffdc9e9; BYTE $0xff // jmp LBB23_4, $-567(%rip) + LONG $0x00558949 // movq %rdx, (%r13) + WORD $0x854d; BYTE $0xff // testq %r15, %r15 + LONG $0xfc97890f; WORD $0xffff // jns LBB18_61, $-873(%rip) + LONG $0x0001e9e9; BYTE $0x00 // jmp LBB18_77, $489(%rip) -LBB23_37: - WORD $0xff48; BYTE $0xcb // decq %rbx - WORD $0x894c; BYTE $0xe8 // movq %r13, %rax - WORD $0x8949; BYTE $0xdd // movq %rbx, %r13 +LBB18_53: + LONG $0xfffd8149; WORD $0x000f; BYTE $0x00 // cmpq $4095, %r13 + LONG $0x01ee8f0f; WORD $0x0000 // jg LBB18_80, $494(%rip) + LONG $0x01458d49 // leaq $1(%r13), %rax + LONG $0x24048949 // movq %rax, (%r12) + QUAD $0x00000008ec44c74b; BYTE $0x00 // movq $0, $8(%r12,%r13,8) + LONG $0xfffc6fe9; BYTE $0xff // jmp LBB18_61, $-913(%rip) -LBB23_38: - LONG $0xc8658b4c // movq $-56(%rbp), %r12 +LBB18_55: + LONG $0xfffd8149; WORD $0x000f; BYTE $0x00 // cmpq $4095, %r13 + LONG $0x01cb8f0f; WORD $0x0000 // jg LBB18_80, $459(%rip) + LONG $0x01458d49 // leaq $1(%r13), %rax LONG $0x24048949 // movq %rax, (%r12) - WORD $0x854d; BYTE $0xed // testq %r13, %r13 - LONG $0x0136880f; WORD $0x0000 // js LBB23_55, $310(%rip) - WORD $0x8b49; BYTE $0x0f // movq (%r15), %rcx - LONG $0x000004b8; BYTE $0x00 // movl $4, %eax - LONG $0xfff98148; WORD $0x000f; BYTE $0x00 // cmpq $4095, %rcx - LONG $0xfd9a8e0f; WORD $0xffff // jle LBB23_4, $-614(%rip) - LONG $0x00013ae9; BYTE $0x00 // jmp LBB23_62, $314(%rip) - -LBB23_40: - LONG $0x241c8b49 // movq (%r12), %rbx - LONG $0xd07d8b48 // movq $-48(%rbp), %rdi - LONG $0xfffe69e9; BYTE $0xff // jmp LBB23_20, $-407(%rip) - -LBB23_41: - LONG $0x242c8b4d // movq (%r12), %r13 - LONG $0xd0458b48 // movq $-48(%rbp), %rax - WORD $0x8b48; BYTE $0x38 // movq (%rax), %rdi - WORD $0x014c; BYTE $0xef // addq %r13, %rdi - LONG $0x08708b48 // movq $8(%rax), %rsi - WORD $0x294c; BYTE $0xee // subq %r13, %rsi - LONG $0x0005bee8; BYTE $0x00 // callq _do_skip_number, $1470(%rip) - WORD $0x8548; BYTE $0xc0 // testq %rax, %rax - LONG $0x0126880f; WORD $0x0000 // js LBB23_66, $294(%rip) - WORD $0x014c; BYTE $0xe8 // addq %r13, %rax - LONG $0x24048949 // movq %rax, (%r12) - WORD $0x854d; BYTE $0xed // testq %r13, %r13 - LONG $0xfd648f0f; WORD $0xffff // jg LBB23_6, $-668(%rip) - LONG $0x000127e9; BYTE $0x00 // jmp LBB23_68, $295(%rip) - -LBB23_43: - WORD $0x8b49; BYTE $0x0f // movq (%r15), %rcx - LONG $0x000005b8; BYTE $0x00 // movl $5, %eax - LONG $0xfff98148; WORD $0x000f; BYTE $0x00 // cmpq $4095, %rcx - LONG $0xfd3b8e0f; WORD $0xffff // jle LBB23_4, $-709(%rip) - LONG $0x0000dbe9; BYTE $0x00 // jmp LBB23_62, $219(%rip) - -LBB23_44: - LONG $0x24048b49 // movq (%r12), %rax - LONG $0xd0758b48 // movq $-48(%rbp), %rsi - LONG $0x084e8b48 // movq $8(%rsi), %rcx + QUAD $0x00000308ec44c74b; BYTE $0x00 // movq $3, $8(%r12,%r13,8) + LONG $0xfffc4ce9; BYTE $0xff // jmp LBB18_61, $-948(%rip) + +LBB18_57: + QUAD $0x00000002ec04c74b // movq $2, (%r12,%r13,8) + QUAD $0xffffffffc845c748 // movq $-1, $-56(%rbp) + WORD $0x8b4d; BYTE $0x28 // movq (%r8), %r13 + WORD $0x8948; BYTE $0xf7 // movq %rsi, %rdi + WORD $0x894c; BYTE $0xee // movq %r13, %rsi + LONG $0xc8558d48 // leaq $-56(%rbp), %rdx + LONG $0xb84d8b48 // movq $-72(%rbp), %rcx + WORD $0x894c; BYTE $0xc3 // movq %r8, %rbx + LONG $0xffed13e8; BYTE $0xff // callq _advance_string, $-4845(%rip) + WORD $0x8949; BYTE $0xc7 // movq %rax, %r15 + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0x018c880f; WORD $0x0000 // js LBB18_78, $396(%rip) + WORD $0x894c; BYTE $0x3b // movq %r15, (%rbx) + WORD $0x854d; BYTE $0xed // testq %r13, %r13 + LONG $0x01988e0f; WORD $0x0000 // jle LBB18_79, $408(%rip) + LONG $0x24048b49 // movq (%r12), %rax + LONG $0x0fff3d48; WORD $0x0000 // cmpq $4095, %rax + LONG $0x01648f0f; WORD $0x0000 // jg LBB18_80, $356(%rip) + WORD $0x8949; BYTE $0xd8 // movq %rbx, %r8 + LONG $0x01488d48 // leaq $1(%rax), %rcx + LONG $0x240c8949 // movq %rcx, (%r12) + QUAD $0x00000408c444c749; BYTE $0x00 // movq $4, $8(%r12,%rax,8) + LONG $0xc0758b48 // movq $-64(%rbp), %rsi + QUAD $0x000100002600bb49; WORD $0x0000 // movabsq $4294977024, %r11 + LONG $0xfffbd4e9; BYTE $0xff // jmp LBB18_61, $-1068(%rip) + +LBB18_62: + WORD $0x8b4d; BYTE $0x38 // movq (%r8), %r15 + WORD $0x014c; BYTE $0xff // addq %r15, %rdi + LONG $0xd0458b48 // movq $-48(%rbp), %rax + WORD $0x8b48; BYTE $0x30 // movq (%rax), %rsi + WORD $0x294c; BYTE $0xfe // subq %r15, %rsi + WORD $0x894c; BYTE $0xc3 // movq %r8, %rbx + LONG $0x00060ce8; BYTE $0x00 // callq _do_skip_number, $1548(%rip) + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0x015e880f; WORD $0x0000 // js LBB18_84, $350(%rip) + WORD $0x014c; BYTE $0xf8 // addq %r15, %rax + WORD $0x8948; BYTE $0x03 // movq %rax, (%rbx) + WORD $0x854d; BYTE $0xff // testq %r15, %r15 + WORD $0x8949; BYTE $0xd8 // movq %rbx, %r8 + LONG $0xc0758b48 // movq $-64(%rbp), %rsi + QUAD $0x000100002600bb49; WORD $0x0000 // movabsq $4294977024, %r11 + LONG $0xfb938f0f; WORD $0xffff // jg LBB18_61, $-1133(%rip) + LONG $0x00014ee9; BYTE $0x00 // jmp LBB18_91, $334(%rip) + +LBB18_64: + LONG $0x24048b49 // movq (%r12), %rax + LONG $0x0fff3d48; WORD $0x0000 // cmpq $4095, %rax + LONG $0x00e78f0f; WORD $0x0000 // jg LBB18_80, $231(%rip) + LONG $0x01488d48 // leaq $1(%rax), %rcx + LONG $0x240c8949 // movq %rcx, (%r12) + QUAD $0x00000508c444c749; BYTE $0x00 // movq $5, $8(%r12,%rax,8) + LONG $0xfffb68e9; BYTE $0xff // jmp LBB18_61, $-1176(%rip) + +LBB18_66: + WORD $0x8b49; BYTE $0x00 // movq (%r8), %rax + LONG $0xd04d8b48 // movq $-48(%rbp), %rcx + WORD $0x8b48; BYTE $0x09 // movq (%rcx), %rcx LONG $0xfc518d48 // leaq $-4(%rcx), %rdx WORD $0x3948; BYTE $0xd0 // cmpq %rdx, %rax - LONG $0x00ce870f; WORD $0x0000 // ja LBB23_64, $206(%rip) - WORD $0x8b48; BYTE $0x0e // movq (%rsi), %rcx - WORD $0x148b; BYTE $0x01 // movl (%rcx,%rax), %edx - LONG $0x6c61fa81; WORD $0x6573 // cmpl $1702063201, %edx - LONG $0x0198850f; WORD $0x0000 // jne LBB23_78, $408(%rip) + LONG $0x00e9870f; WORD $0x0000 // ja LBB18_88, $233(%rip) + WORD $0x0c8b; BYTE $0x07 // movl (%rdi,%rax), %ecx + LONG $0x6c61f981; WORD $0x6573 // cmpl $1702063201, %ecx + LONG $0x010a850f; WORD $0x0000 // jne LBB18_92, $266(%rip) LONG $0x04488d48 // leaq $4(%rax), %rcx - LONG $0x240c8949 // movq %rcx, (%r12) + WORD $0x8949; BYTE $0x08 // movq %rcx, (%r8) WORD $0x8548; BYTE $0xc0 // testq %rax, %rax - LONG $0xfd098f0f; WORD $0xffff // jg LBB23_6, $-759(%rip) - LONG $0x00006ae9; BYTE $0x00 // jmp LBB23_52, $106(%rip) + LONG $0xfb328f0f; WORD $0xffff // jg LBB18_61, $-1230(%rip) + LONG $0x0000cde9; BYTE $0x00 // jmp LBB18_83, $205(%rip) -LBB23_47: - LONG $0x24048b49 // movq (%r12), %rax - LONG $0xd0758b48 // movq $-48(%rbp), %rsi - LONG $0x084e8b48 // movq $8(%rsi), %rcx +LBB18_69: + WORD $0x8b49; BYTE $0x00 // movq (%r8), %rax + LONG $0xd04d8b48 // movq $-48(%rbp), %rcx + WORD $0x8b48; BYTE $0x09 // movq (%rcx), %rcx LONG $0xfd518d48 // leaq $-3(%rcx), %rdx WORD $0x3948; BYTE $0xd0 // cmpq %rdx, %rax - LONG $0x008d870f; WORD $0x0000 // ja LBB23_64, $141(%rip) - WORD $0x8b48; BYTE $0x0e // movq (%rsi), %rcx - QUAD $0x6c6c756eff017c81 // cmpl $1819047278, $-1(%rcx,%rax) - LONG $0x002f840f; WORD $0x0000 // je LBB23_51, $47(%rip) - LONG $0x0000a5e9; BYTE $0x00 // jmp LBB23_69, $165(%rip) - -LBB23_49: - LONG $0x24048b49 // movq (%r12), %rax - LONG $0xd0758b48 // movq $-48(%rbp), %rsi - LONG $0x084e8b48 // movq $8(%rsi), %rcx + LONG $0x00ae870f; WORD $0x0000 // ja LBB18_88, $174(%rip) + QUAD $0x6c6c756eff077c81 // cmpl $1819047278, $-1(%rdi,%rax) + LONG $0xfaef840f; WORD $0xffff // je LBB18_2, $-1297(%rip) + LONG $0x00011de9; BYTE $0x00 // jmp LBB18_97, $285(%rip) + +LBB18_71: + WORD $0x8b49; BYTE $0x00 // movq (%r8), %rax + LONG $0xd04d8b48 // movq $-48(%rbp), %rcx + WORD $0x8b48; BYTE $0x09 // movq (%rcx), %rcx LONG $0xfd518d48 // leaq $-3(%rcx), %rdx WORD $0x3948; BYTE $0xd0 // cmpq %rdx, %rax - LONG $0x005e870f; WORD $0x0000 // ja LBB23_64, $94(%rip) - WORD $0x8b48; BYTE $0x0e // movq (%rsi), %rcx - QUAD $0x65757274ff017c81 // cmpl $1702195828, $-1(%rcx,%rax) - LONG $0x00ce850f; WORD $0x0000 // jne LBB23_73, $206(%rip) - -LBB23_51: - LONG $0x03488d48 // leaq $3(%rax), %rcx - LONG $0x240c8949 // movq %rcx, (%r12) - WORD $0x8548; BYTE $0xc0 // testq %rax, %rax - LONG $0xfc9a8f0f; WORD $0xffff // jg LBB23_6, $-870(%rip) - -LBB23_52: - WORD $0xff48; BYTE $0xc8 // decq %rax - -LBB23_54: - WORD $0x8949; BYTE $0xc5 // movq %rax, %r13 - LONG $0x000007e9; BYTE $0x00 // jmp LBB23_55, $7(%rip) - -LBB23_2: - LONG $0xffc5c749; WORD $0xffff; BYTE $0xff // movq $-1, %r13 + LONG $0x0084870f; WORD $0x0000 // ja LBB18_88, $132(%rip) + QUAD $0x65757274ff077c81 // cmpl $1702195828, $-1(%rdi,%rax) + LONG $0xfac5840f; WORD $0xffff // je LBB18_2, $-1339(%rip) + LONG $0x000142e9; BYTE $0x00 // jmp LBB18_101, $322(%rip) + +LBB18_73: + LONG $0x24048b49 // movq (%r12), %rax + LONG $0x0fff3d48; WORD $0x0000 // cmpq $4095, %rax + LONG $0x00328f0f; WORD $0x0000 // jg LBB18_80, $50(%rip) + LONG $0x01488d48 // leaq $1(%rax), %rcx + LONG $0x240c8949 // movq %rcx, (%r12) + QUAD $0x00000608c444c749; BYTE $0x00 // movq $6, $8(%r12,%rax,8) + LONG $0xfffab3e9; BYTE $0xff // jmp LBB18_61, $-1357(%rip) + +LBB18_75: + WORD $0x8949; BYTE $0x18 // movq %rbx, (%r8) + +LBB18_76: + LONG $0xffc7c749; WORD $0xffff; BYTE $0xff // movq $-1, %r15 -LBB23_55: - WORD $0x894c; BYTE $0xe8 // movq %r13, %rax +LBB18_77: + WORD $0x894c; BYTE $0xf8 // movq %r15, %rax LONG $0x28c48348 // addq $40, %rsp BYTE $0x5b // popq %rbx WORD $0x5c41 // popq %r12 @@ -6280,245 +5658,260 @@ LBB23_55: BYTE $0x5d // popq %rbp BYTE $0xc3 // retq -LBB23_58: - LONG $0xfec5c749; WORD $0xffff; BYTE $0xff // movq $-2, %r13 - LONG $0xffffe2e9; BYTE $0xff // jmp LBB23_55, $-30(%rip) +LBB18_80: + LONG $0xf9c7c749; WORD $0xffff; BYTE $0xff // movq $-7, %r15 + LONG $0xffffe2e9; BYTE $0xff // jmp LBB18_77, $-30(%rip) -LBB23_62: - LONG $0xf9c5c749; WORD $0xffff; BYTE $0xff // movq $-7, %r13 - LONG $0xffffd6e9; BYTE $0xff // jmp LBB23_55, $-42(%rip) +LBB18_78: + LONG $0xffff8349 // cmpq $-1, %r15 + LONG $0xc8458d48 // leaq $-56(%rbp), %rax + LONG $0x45440f48; BYTE $0xd0 // cmoveq $-48(%rbp), %rax + WORD $0x8b48; BYTE $0x00 // movq (%rax), %rax + WORD $0x8948; BYTE $0x03 // movq %rax, (%rbx) + LONG $0xffffcae9; BYTE $0xff // jmp LBB18_77, $-54(%rip) -LBB23_64: - LONG $0x240c8949 // movq %rcx, (%r12) - LONG $0xffc5c749; WORD $0xffff; BYTE $0xff // movq $-1, %r13 - LONG $0xffffc6e9; BYTE $0xff // jmp LBB23_55, $-58(%rip) +LBB18_79: + WORD $0xff49; BYTE $0xcd // decq %r13 + WORD $0x894d; BYTE $0xef // movq %r13, %r15 + LONG $0xffffbfe9; BYTE $0xff // jmp LBB18_77, $-65(%rip) -LBB23_66: - WORD $0xf748; BYTE $0xd0 // notq %rax - WORD $0x0149; BYTE $0xc5 // addq %rax, %r13 - LONG $0x242c894d // movq %r13, (%r12) - LONG $0xfec5c749; WORD $0xffff; BYTE $0xff // movq $-2, %r13 - LONG $0xffffb0e9; BYTE $0xff // jmp LBB23_55, $-80(%rip) +LBB18_88: + WORD $0x8949; BYTE $0x08 // movq %rcx, (%r8) + LONG $0xffffb7e9; BYTE $0xff // jmp LBB18_77, $-73(%rip) -LBB23_68: - WORD $0xff49; BYTE $0xcd // decq %r13 - LONG $0xffffa8e9; BYTE $0xff // jmp LBB23_55, $-88(%rip) +LBB18_83: + WORD $0xff48; BYTE $0xc8 // decq %rax + WORD $0x8949; BYTE $0xc7 // movq %rax, %r15 + LONG $0xfffface9; BYTE $0xff // jmp LBB18_77, $-84(%rip) -LBB23_69: - LONG $0xff508d48 // leaq $-1(%rax), %rdx - LONG $0x24148949 // movq %rdx, (%r12) - LONG $0xfec5c749; WORD $0xffff; BYTE $0xff // movq $-2, %r13 - LONG $0xff017c80; BYTE $0x6e // cmpb $110, $-1(%rcx,%rax) - LONG $0xff8e850f; WORD $0xffff // jne LBB23_55, $-114(%rip) - LONG $0x24048949 // movq %rax, (%r12) - LONG $0x75013c80 // cmpb $117, (%rcx,%rax) - LONG $0xff80850f; WORD $0xffff // jne LBB23_55, $-128(%rip) - LONG $0x01508d48 // leaq $1(%rax), %rdx - LONG $0x24148949 // movq %rdx, (%r12) - LONG $0x01017c80; BYTE $0x6c // cmpb $108, $1(%rcx,%rax) - LONG $0xff6d850f; WORD $0xffff // jne LBB23_55, $-147(%rip) - LONG $0x02508d48 // leaq $2(%rax), %rdx - LONG $0x24148949 // movq %rdx, (%r12) - LONG $0x02017c80; BYTE $0x6c // cmpb $108, $2(%rcx,%rax) - LONG $0xff5a850f; WORD $0xffff // jne LBB23_55, $-166(%rip) - LONG $0x00004ee9; BYTE $0x00 // jmp LBB23_77, $78(%rip) - -LBB23_73: - LONG $0xff508d48 // leaq $-1(%rax), %rdx - LONG $0x24148949 // movq %rdx, (%r12) - LONG $0xfec5c749; WORD $0xffff; BYTE $0xff // movq $-2, %r13 - LONG $0xff017c80; BYTE $0x74 // cmpb $116, $-1(%rcx,%rax) - LONG $0xff3b850f; WORD $0xffff // jne LBB23_55, $-197(%rip) - LONG $0x24048949 // movq %rax, (%r12) - LONG $0x72013c80 // cmpb $114, (%rcx,%rax) - LONG $0xff2d850f; WORD $0xffff // jne LBB23_55, $-211(%rip) - LONG $0x01508d48 // leaq $1(%rax), %rdx - LONG $0x24148949 // movq %rdx, (%r12) - LONG $0x01017c80; BYTE $0x75 // cmpb $117, $1(%rcx,%rax) - LONG $0xff1a850f; WORD $0xffff // jne LBB23_55, $-230(%rip) - LONG $0x02508d48 // leaq $2(%rax), %rdx - LONG $0x24148949 // movq %rdx, (%r12) - LONG $0x02017c80; BYTE $0x65 // cmpb $101, $2(%rcx,%rax) - LONG $0xff07850f; WORD $0xffff // jne LBB23_55, $-249(%rip) - -LBB23_77: - LONG $0x03c08348 // addq $3, %rax - LONG $0x24048949 // movq %rax, (%r12) - LONG $0xfffefae9; BYTE $0xff // jmp LBB23_55, $-262(%rip) - -LBB23_78: - LONG $0xfec5c749; WORD $0xffff; BYTE $0xff // movq $-2, %r13 - WORD $0xfa80; BYTE $0x61 // cmpb $97, %dl - LONG $0xfeea850f; WORD $0xffff // jne LBB23_55, $-278(%rip) - LONG $0x01508d48 // leaq $1(%rax), %rdx - LONG $0x24148949 // movq %rdx, (%r12) - LONG $0x01017c80; BYTE $0x6c // cmpb $108, $1(%rcx,%rax) - LONG $0xfed7850f; WORD $0xffff // jne LBB23_55, $-297(%rip) - LONG $0x02508d48 // leaq $2(%rax), %rdx - LONG $0x24148949 // movq %rdx, (%r12) - LONG $0x02017c80; BYTE $0x73 // cmpb $115, $2(%rcx,%rax) - LONG $0xfec4850f; WORD $0xffff // jne LBB23_55, $-316(%rip) - LONG $0x03508d48 // leaq $3(%rax), %rdx - LONG $0x24148949 // movq %rdx, (%r12) - LONG $0x03017c80; BYTE $0x65 // cmpb $101, $3(%rcx,%rax) - LONG $0xfeb1850f; WORD $0xffff // jne LBB23_55, $-335(%rip) +LBB18_84: + WORD $0xf748; BYTE $0xd0 // notq %rax + WORD $0x0149; BYTE $0xc7 // addq %rax, %r15 + WORD $0x894c; BYTE $0x3b // movq %r15, (%rbx) + +LBB18_85: + LONG $0xfec7c749; WORD $0xffff; BYTE $0xff // movq $-2, %r15 + LONG $0xffff97e9; BYTE $0xff // jmp LBB18_77, $-105(%rip) + +LBB18_91: + WORD $0xff49; BYTE $0xcf // decq %r15 + LONG $0xffff8fe9; BYTE $0xff // jmp LBB18_77, $-113(%rip) + +LBB18_92: + LONG $0xfec7c749; WORD $0xffff; BYTE $0xff // movq $-2, %r15 + WORD $0xf980; BYTE $0x61 // cmpb $97, %cl + LONG $0xff7f850f; WORD $0xffff // jne LBB18_77, $-129(%rip) + LONG $0x01488d48 // leaq $1(%rax), %rcx + WORD $0x8949; BYTE $0x08 // movq %rcx, (%r8) + LONG $0x01077c80; BYTE $0x6c // cmpb $108, $1(%rdi,%rax) + LONG $0xff6d850f; WORD $0xffff // jne LBB18_77, $-147(%rip) + LONG $0x02488d48 // leaq $2(%rax), %rcx + WORD $0x8949; BYTE $0x08 // movq %rcx, (%r8) + LONG $0x02077c80; BYTE $0x73 // cmpb $115, $2(%rdi,%rax) + LONG $0xff5b850f; WORD $0xffff // jne LBB18_77, $-165(%rip) + LONG $0x03488d48 // leaq $3(%rax), %rcx + WORD $0x8949; BYTE $0x08 // movq %rcx, (%r8) + LONG $0x03077c80; BYTE $0x65 // cmpb $101, $3(%rdi,%rax) + LONG $0xff49850f; WORD $0xffff // jne LBB18_77, $-183(%rip) LONG $0x04c08348 // addq $4, %rax - LONG $0x24048949 // movq %rax, (%r12) - LONG $0xfffea4e9; BYTE $0xff // jmp LBB23_55, $-348(%rip) - BYTE $0x90 // .p2align 2, 0x90 - - // .set L23_0_set_12, LBB23_12-LJTI23_0 - // .set L23_0_set_15, LBB23_15-LJTI23_0 - // .set L23_0_set_18, LBB23_18-LJTI23_0 - // .set L23_0_set_22, LBB23_22-LJTI23_0 - // .set L23_0_set_24, LBB23_24-LJTI23_0 - // .set L23_0_set_28, LBB23_28-LJTI23_0 -LJTI23_0: - LONG $0xfffffb8e // .long L23_0_set_12 - LONG $0xfffffbbd // .long L23_0_set_15 - LONG $0xfffffbe6 // .long L23_0_set_18 - LONG $0xfffffc22 // .long L23_0_set_22 - LONG $0xfffffc31 // .long L23_0_set_24 - LONG $0xfffffcc4 // .long L23_0_set_28 - - // .set L23_1_set_55, LBB23_55-LJTI23_1 - // .set L23_1_set_54, LBB23_54-LJTI23_1 - // .set L23_1_set_40, LBB23_40-LJTI23_1 - // .set L23_1_set_41, LBB23_41-LJTI23_1 - // .set L23_1_set_27, LBB23_27-LJTI23_1 - // .set L23_1_set_43, LBB23_43-LJTI23_1 - // .set L23_1_set_44, LBB23_44-LJTI23_1 - // .set L23_1_set_47, LBB23_47-LJTI23_1 - // .set L23_1_set_49, LBB23_49-LJTI23_1 - // .set L23_1_set_3, LBB23_3-LJTI23_1 -LJTI23_1: - LONG $0xfffffe8b // .long L23_1_set_55 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffd6f // .long L23_1_set_40 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffd7c // .long L23_1_set_41 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffc52 // .long L23_1_set_27 - LONG $0xfffffc52 // .long L23_1_set_27 - LONG $0xfffffc52 // .long L23_1_set_27 - LONG $0xfffffc52 // .long L23_1_set_27 - LONG $0xfffffc52 // .long L23_1_set_27 - LONG $0xfffffc52 // .long L23_1_set_27 - LONG $0xfffffc52 // .long L23_1_set_27 - LONG $0xfffffc52 // .long L23_1_set_27 - LONG $0xfffffc52 // .long L23_1_set_27 - LONG $0xfffffc52 // .long L23_1_set_27 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffdb4 // .long L23_1_set_43 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffdce // .long L23_1_set_44 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe0f // .long L23_1_set_47 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe3e // .long L23_1_set_49 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffaed // .long L23_1_set_3 - LONG $0x00000000 // .p2align 4, 0x00 - -LCPI24_0: + WORD $0x8949; BYTE $0x00 // movq %rax, (%r8) + LONG $0xffff3de9; BYTE $0xff // jmp LBB18_77, $-195(%rip) + +LBB18_97: + LONG $0xff488d48 // leaq $-1(%rax), %rcx + WORD $0x8949; BYTE $0x08 // movq %rcx, (%r8) + LONG $0xfec7c749; WORD $0xffff; BYTE $0xff // movq $-2, %r15 + LONG $0xff077c80; BYTE $0x6e // cmpb $110, $-1(%rdi,%rax) + LONG $0xff24850f; WORD $0xffff // jne LBB18_77, $-220(%rip) + WORD $0x8949; BYTE $0x00 // movq %rax, (%r8) + LONG $0x75073c80 // cmpb $117, (%rdi,%rax) + LONG $0xff17850f; WORD $0xffff // jne LBB18_77, $-233(%rip) + LONG $0x01488d48 // leaq $1(%rax), %rcx + WORD $0x8949; BYTE $0x08 // movq %rcx, (%r8) + LONG $0x01077c80; BYTE $0x6c // cmpb $108, $1(%rdi,%rax) + LONG $0xff05850f; WORD $0xffff // jne LBB18_77, $-251(%rip) + LONG $0x02488d48 // leaq $2(%rax), %rcx + WORD $0x8949; BYTE $0x08 // movq %rcx, (%r8) + LONG $0x02077c80; BYTE $0x6c // cmpb $108, $2(%rdi,%rax) + LONG $0xfef3850f; WORD $0xffff // jne LBB18_77, $-269(%rip) + LONG $0x00004ae9; BYTE $0x00 // jmp LBB18_105, $74(%rip) + +LBB18_101: + LONG $0xff488d48 // leaq $-1(%rax), %rcx + WORD $0x8949; BYTE $0x08 // movq %rcx, (%r8) + LONG $0xfec7c749; WORD $0xffff; BYTE $0xff // movq $-2, %r15 + LONG $0xff077c80; BYTE $0x74 // cmpb $116, $-1(%rdi,%rax) + LONG $0xfed5850f; WORD $0xffff // jne LBB18_77, $-299(%rip) + WORD $0x8949; BYTE $0x00 // movq %rax, (%r8) + LONG $0x72073c80 // cmpb $114, (%rdi,%rax) + LONG $0xfec8850f; WORD $0xffff // jne LBB18_77, $-312(%rip) + LONG $0x01488d48 // leaq $1(%rax), %rcx + WORD $0x8949; BYTE $0x08 // movq %rcx, (%r8) + LONG $0x01077c80; BYTE $0x75 // cmpb $117, $1(%rdi,%rax) + LONG $0xfeb6850f; WORD $0xffff // jne LBB18_77, $-330(%rip) + LONG $0x02488d48 // leaq $2(%rax), %rcx + WORD $0x8949; BYTE $0x08 // movq %rcx, (%r8) + LONG $0x02077c80; BYTE $0x65 // cmpb $101, $2(%rdi,%rax) + LONG $0xfea4850f; WORD $0xffff // jne LBB18_77, $-348(%rip) + +LBB18_105: + LONG $0x03c08348 // addq $3, %rax + WORD $0x8949; BYTE $0x00 // movq %rax, (%r8) + LONG $0xfffe98e9; BYTE $0xff // jmp LBB18_77, $-360(%rip) + BYTE $0x90 // .p2align 2, 0x90 + + // .set L18_0_set_32, LBB18_32-LJTI18_0 + // .set L18_0_set_36, LBB18_36-LJTI18_0 + // .set L18_0_set_39, LBB18_39-LJTI18_0 + // .set L18_0_set_43, LBB18_43-LJTI18_0 + // .set L18_0_set_45, LBB18_45-LJTI18_0 + // .set L18_0_set_47, LBB18_47-LJTI18_0 +LJTI18_0: + LONG $0xfffffb0c // .long L18_0_set_32 + LONG $0xfffffb45 // .long L18_0_set_36 + LONG $0xfffffb6c // .long L18_0_set_39 + LONG $0xfffffbcc // .long L18_0_set_43 + LONG $0xfffffbe2 // .long L18_0_set_45 + LONG $0xfffffc00 // .long L18_0_set_47 + + // .set L18_1_set_77, LBB18_77-LJTI18_1 + // .set L18_1_set_85, LBB18_85-LJTI18_1 + // .set L18_1_set_41, LBB18_41-LJTI18_1 + // .set L18_1_set_62, LBB18_62-LJTI18_1 + // .set L18_1_set_52, LBB18_52-LJTI18_1 + // .set L18_1_set_64, LBB18_64-LJTI18_1 + // .set L18_1_set_66, LBB18_66-LJTI18_1 + // .set L18_1_set_69, LBB18_69-LJTI18_1 + // .set L18_1_set_71, LBB18_71-LJTI18_1 + // .set L18_1_set_73, LBB18_73-LJTI18_1 +LJTI18_1: + LONG $0xfffffe7f // .long L18_1_set_77 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffb65 // .long L18_1_set_41 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffd54 // .long L18_1_set_62 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffc32 // .long L18_1_set_52 + LONG $0xfffffc32 // .long L18_1_set_52 + LONG $0xfffffc32 // .long L18_1_set_52 + LONG $0xfffffc32 // .long L18_1_set_52 + LONG $0xfffffc32 // .long L18_1_set_52 + LONG $0xfffffc32 // .long L18_1_set_52 + LONG $0xfffffc32 // .long L18_1_set_52 + LONG $0xfffffc32 // .long L18_1_set_52 + LONG $0xfffffc32 // .long L18_1_set_52 + LONG $0xfffffc32 // .long L18_1_set_52 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffd9a // .long L18_1_set_64 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffdc0 // .long L18_1_set_66 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffdfb // .long L18_1_set_69 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffe25 // .long L18_1_set_71 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffe4f // .long L18_1_set_73 + QUAD $0x0000000000000000 // .p2align 4, 0x00 + +LCPI19_0: QUAD $0x0000000000000001 // .quad 1 QUAD $0x0000000000000006 // .quad 6 @@ -6529,43 +5922,53 @@ _skip_object: WORD $0x8948; BYTE $0xd0 // movq %rdx, %rax WORD $0x8948; BYTE $0xf2 // movq %rsi, %rdx WORD $0x8948; BYTE $0xfe // movq %rdi, %rsi - QUAD $0xffffffdb0528f8c5 // vmovaps $-37(%rip), %xmm0 /* LCPI24_0(%rip) */ + QUAD $0xffffffdb0528f8c5 // vmovaps $-37(%rip), %xmm0 /* LCPI19_0(%rip) */ LONG $0x0011f8c5 // vmovups %xmm0, (%rax) WORD $0x8948; BYTE $0xc7 // movq %rax, %rdi BYTE $0x5d // popq %rbp - LONG $0xfff88ee9; BYTE $0xff // jmp _fsm_exec, $-1906(%rip) + LONG $0xfff69ee9; BYTE $0xff // jmp _fsm_exec, $-2402(%rip) QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 _skip_string: BYTE $0x55 // pushq %rbp WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5741 // pushq %r15 WORD $0x5641 // pushq %r14 + WORD $0x5441 // pushq %r12 BYTE $0x53 // pushq %rbx LONG $0x10ec8348 // subq $16, %rsp WORD $0x8948; BYTE $0xd1 // movq %rdx, %rcx WORD $0x8949; BYTE $0xf6 // movq %rsi, %r14 + WORD $0x8949; BYTE $0xff // movq %rdi, %r15 + QUAD $0xffffffffd845c748 // movq $-1, $-40(%rbp) WORD $0x8b48; BYTE $0x1e // movq (%rsi), %rbx - LONG $0xe8558d48 // leaq $-24(%rbp), %rdx + LONG $0xd8658d4c // leaq $-40(%rbp), %r12 WORD $0x8948; BYTE $0xde // movq %rbx, %rsi - LONG $0xffea60e8; BYTE $0xff // callq _advance_string, $-5536(%rip) + WORD $0x894c; BYTE $0xe2 // movq %r12, %rdx + LONG $0xffe7aee8; BYTE $0xff // callq _advance_string, $-6226(%rip) WORD $0x8548; BYTE $0xc0 // testq %rax, %rax - LONG $0x0009890f; WORD $0x0000 // jns LBB25_1, $9(%rip) - LONG $0xe84d8b48 // movq $-24(%rbp), %rcx - LONG $0x000009e9; BYTE $0x00 // jmp LBB25_3, $9(%rip) + LONG $0x000e880f; WORD $0x0000 // js LBB20_1, $14(%rip) + WORD $0xff48; BYTE $0xcb // decq %rbx + WORD $0x8948; BYTE $0xc1 // movq %rax, %rcx + WORD $0x8948; BYTE $0xd8 // movq %rbx, %rax + LONG $0x000010e9; BYTE $0x00 // jmp LBB20_3, $16(%rip) -LBB25_1: - WORD $0xff48; BYTE $0xcb // decq %rbx - WORD $0x8948; BYTE $0xc1 // movq %rax, %rcx - WORD $0x8948; BYTE $0xd8 // movq %rbx, %rax +LBB20_1: + LONG $0x08c78349 // addq $8, %r15 + LONG $0xfff88348 // cmpq $-1, %rax + LONG $0xe7440f4d // cmoveq %r15, %r12 + LONG $0x240c8b49 // movq (%r12), %rcx -LBB25_3: - WORD $0x8949; BYTE $0x0e // movq %rcx, (%r14) - LONG $0x10c48348 // addq $16, %rsp - BYTE $0x5b // popq %rbx - WORD $0x5e41 // popq %r14 - BYTE $0x5d // popq %rbp - BYTE $0xc3 // retq - QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90 +LBB20_3: + WORD $0x8949; BYTE $0x0e // movq %rcx, (%r14) + LONG $0x10c48348 // addq $16, %rsp + BYTE $0x5b // popq %rbx + WORD $0x5c41 // popq %r12 + WORD $0x5e41 // popq %r14 + WORD $0x5f41 // popq %r15 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 _skip_negative: BYTE $0x55 // pushq %rbp @@ -6581,19 +5984,19 @@ _skip_negative: WORD $0x8948; BYTE $0xc7 // movq %rax, %rdi LONG $0x0000aee8; BYTE $0x00 // callq _do_skip_number, $174(%rip) WORD $0x8548; BYTE $0xc0 // testq %rax, %rax - LONG $0x000e880f; WORD $0x0000 // js LBB26_1, $14(%rip) + LONG $0x000e880f; WORD $0x0000 // js LBB21_1, $14(%rip) WORD $0x0148; BYTE $0xd8 // addq %rbx, %rax WORD $0x8949; BYTE $0x06 // movq %rax, (%r14) WORD $0xff48; BYTE $0xcb // decq %rbx - LONG $0x000010e9; BYTE $0x00 // jmp LBB26_3, $16(%rip) + LONG $0x000010e9; BYTE $0x00 // jmp LBB21_3, $16(%rip) -LBB26_1: +LBB21_1: WORD $0xf748; BYTE $0xd0 // notq %rax WORD $0x0148; BYTE $0xc3 // addq %rax, %rbx WORD $0x8949; BYTE $0x1e // movq %rbx, (%r14) LONG $0xfec3c748; WORD $0xffff; BYTE $0xff // movq $-2, %rbx -LBB26_3: +LBB21_3: WORD $0x8948; BYTE $0xd8 // movq %rbx, %rax BYTE $0x5b // popq %rbx WORD $0x5e41 // popq %r14 @@ -6601,25 +6004,25 @@ LBB26_3: BYTE $0xc3 // retq QUAD $0x0000000000000000; LONG $0x00000000; WORD $0x0000; BYTE $0x00 // .p2align 4, 0x00 -LCPI27_0: - QUAD $0x2b2b2b2b2b2b2b2b; QUAD $0x2b2b2b2b2b2b2b2b // .space 16, '++++++++++++++++' +LCPI22_0: + QUAD $0x2f2f2f2f2f2f2f2f; QUAD $0x2f2f2f2f2f2f2f2f // .space 16, '////////////////' -LCPI27_1: - QUAD $0x2d2d2d2d2d2d2d2d; QUAD $0x2d2d2d2d2d2d2d2d // .space 16, '----------------' +LCPI22_1: + QUAD $0x3a3a3a3a3a3a3a3a; QUAD $0x3a3a3a3a3a3a3a3a // .space 16, '::::::::::::::::' -LCPI27_2: - QUAD $0xd0d0d0d0d0d0d0d0; QUAD $0xd0d0d0d0d0d0d0d0 // .space 16, '\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0' +LCPI22_2: + QUAD $0x2b2b2b2b2b2b2b2b; QUAD $0x2b2b2b2b2b2b2b2b // .space 16, '++++++++++++++++' -LCPI27_3: - QUAD $0x0909090909090909; QUAD $0x0909090909090909 // .space 16, '\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t' +LCPI22_3: + QUAD $0x2d2d2d2d2d2d2d2d; QUAD $0x2d2d2d2d2d2d2d2d // .space 16, '----------------' -LCPI27_4: +LCPI22_4: QUAD $0xdfdfdfdfdfdfdfdf; QUAD $0xdfdfdfdfdfdfdfdf // .space 16, '\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf' -LCPI27_5: +LCPI22_5: QUAD $0x2e2e2e2e2e2e2e2e; QUAD $0x2e2e2e2e2e2e2e2e // .space 16, '................' -LCPI27_6: +LCPI22_6: QUAD $0x4545454545454545; QUAD $0x4545454545454545 // .space 16, 'EEEEEEEEEEEEEEEE' // .p2align 4, 0x90 @@ -6630,299 +6033,334 @@ _do_skip_number: WORD $0x5641 // pushq %r14 BYTE $0x53 // pushq %rbx WORD $0x8548; BYTE $0xf6 // testq %rsi, %rsi - LONG $0x0235840f; WORD $0x0000 // je LBB27_1, $565(%rip) + LONG $0x0248840f; WORD $0x0000 // je LBB22_34, $584(%rip) WORD $0x3f80; BYTE $0x30 // cmpb $48, (%rdi) - LONG $0x0033850f; WORD $0x0000 // jne LBB27_6, $51(%rip) - LONG $0x000001b8; BYTE $0x00 // movl $1, %eax + LONG $0x0033850f; WORD $0x0000 // jne LBB22_5, $51(%rip) + LONG $0x000001ba; BYTE $0x00 // movl $1, %edx LONG $0x01fe8348 // cmpq $1, %rsi - LONG $0x02b8840f; WORD $0x0000 // je LBB27_55, $696(%rip) - LONG $0x014fb60f // movzbl $1(%rdi), %ecx - WORD $0xc183; BYTE $0xd2 // addl $-46, %ecx - WORD $0xf983; BYTE $0x37 // cmpl $55, %ecx - LONG $0x02a8870f; WORD $0x0000 // ja LBB27_55, $680(%rip) - QUAD $0x000000800001ba48; WORD $0x0080 // movabsq $36028797027352577, %rdx - LONG $0xcaa30f48 // btq %rcx, %rdx - LONG $0x0294830f; WORD $0x0000 // jae LBB27_55, $660(%rip) + LONG $0x0301840f; WORD $0x0000 // je LBB22_52, $769(%rip) + WORD $0x478a; BYTE $0x01 // movb $1(%rdi), %al + WORD $0xd204 // addb $-46, %al + WORD $0x373c // cmpb $55, %al + LONG $0x02f4870f; WORD $0x0000 // ja LBB22_52, $756(%rip) + WORD $0xb60f; BYTE $0xc0 // movzbl %al, %eax + QUAD $0x000000800001b948; WORD $0x0080 // movabsq $36028797027352577, %rcx + LONG $0xc1a30f48 // btq %rax, %rcx + LONG $0x02dd830f; WORD $0x0000 // jae LBB22_52, $733(%rip) -LBB27_6: +LBB22_5: LONG $0x10fe8348 // cmpq $16, %rsi - LONG $0x02f3820f; WORD $0x0000 // jb LBB27_7, $755(%rip) - LONG $0xffc2c749; WORD $0xffff; BYTE $0xff // movq $-1, %r10 - WORD $0xc031 // xorl %eax, %eax - QUAD $0xffffff27056f79c5 // vmovdqa $-217(%rip), %xmm8 /* LCPI27_0(%rip) */ - QUAD $0xffffff2f0d6f79c5 // vmovdqa $-209(%rip), %xmm9 /* LCPI27_1(%rip) */ - QUAD $0xffffff37156f79c5 // vmovdqa $-201(%rip), %xmm10 /* LCPI27_2(%rip) */ - QUAD $0xffffff3f1d6ff9c5 // vmovdqa $-193(%rip), %xmm3 /* LCPI27_3(%rip) */ - QUAD $0xffffff47256ff9c5 // vmovdqa $-185(%rip), %xmm4 /* LCPI27_4(%rip) */ - QUAD $0xffffff4f2d6ff9c5 // vmovdqa $-177(%rip), %xmm5 /* LCPI27_5(%rip) */ - QUAD $0xffffff57356ff9c5 // vmovdqa $-169(%rip), %xmm6 /* LCPI27_6(%rip) */ + LONG $0x02fd820f; WORD $0x0000 // jb LBB22_57, $765(%rip) LONG $0xffc1c749; WORD $0xffff; BYTE $0xff // movq $-1, %r9 + QUAD $0xffffff29056f79c5 // vmovdqa $-215(%rip), %xmm8 /* LCPI22_0(%rip) */ + QUAD $0xffffff310d6f79c5 // vmovdqa $-207(%rip), %xmm9 /* LCPI22_1(%rip) */ + QUAD $0xffffff39156f79c5 // vmovdqa $-199(%rip), %xmm10 /* LCPI22_2(%rip) */ + QUAD $0xffffff411d6f79c5 // vmovdqa $-191(%rip), %xmm11 /* LCPI22_3(%rip) */ + QUAD $0xffffff49256ff9c5 // vmovdqa $-183(%rip), %xmm4 /* LCPI22_4(%rip) */ + QUAD $0xffffff512d6ff9c5 // vmovdqa $-175(%rip), %xmm5 /* LCPI22_5(%rip) */ + QUAD $0xffffff59356ff9c5 // vmovdqa $-167(%rip), %xmm6 /* LCPI22_6(%rip) */ + LONG $0xffffbb41; WORD $0xffff // movl $4294967295, %r11d + LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax LONG $0xffc0c749; WORD $0xffff; BYTE $0xff // movq $-1, %r8 - WORD $0x8949; BYTE $0xf7 // movq %rsi, %r15 - LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 + WORD $0x8949; BYTE $0xfa // movq %rdi, %r10 + WORD $0x9090 // .p2align 4, 0x90 -LBB27_9: - LONG $0x3c6ffac5; BYTE $0x07 // vmovdqu (%rdi,%rax), %xmm7 - LONG $0xc774b9c5 // vpcmpeqb %xmm7, %xmm8, %xmm0 - LONG $0xcf74b1c5 // vpcmpeqb %xmm7, %xmm9, %xmm1 - LONG $0xc0ebf1c5 // vpor %xmm0, %xmm1, %xmm0 - LONG $0xcffca9c5 // vpaddb %xmm7, %xmm10, %xmm1 - LONG $0xd3daf1c5 // vpminub %xmm3, %xmm1, %xmm2 - LONG $0xca74f1c5 // vpcmpeqb %xmm2, %xmm1, %xmm1 +LBB22_7: + LONG $0x6f7ac1c4; BYTE $0x3a // vmovdqu (%r10), %xmm7 + LONG $0x6441c1c4; BYTE $0xc0 // vpcmpgtb %xmm8, %xmm7, %xmm0 + LONG $0xcf64b1c5 // vpcmpgtb %xmm7, %xmm9, %xmm1 + LONG $0xc1dbf9c5 // vpand %xmm1, %xmm0, %xmm0 + LONG $0xcf74a9c5 // vpcmpeqb %xmm7, %xmm10, %xmm1 + LONG $0xd774a1c5 // vpcmpeqb %xmm7, %xmm11, %xmm2 + LONG $0xc9ebe9c5 // vpor %xmm1, %xmm2, %xmm1 LONG $0xd4dbc1c5 // vpand %xmm4, %xmm7, %xmm2 LONG $0xd674e9c5 // vpcmpeqb %xmm6, %xmm2, %xmm2 LONG $0xfd74c1c5 // vpcmpeqb %xmm5, %xmm7, %xmm7 - LONG $0xdfd7f9c5 // vpmovmskb %xmm7, %ebx - LONG $0xf2d779c5 // vpmovmskb %xmm2, %r14d - LONG $0xd8d779c5 // vpmovmskb %xmm0, %r11d - LONG $0xd7ebe9c5 // vpor %xmm7, %xmm2, %xmm2 - LONG $0xc0ebe9c5 // vpor %xmm0, %xmm2, %xmm0 - LONG $0xc1ebf9c5 // vpor %xmm1, %xmm0, %xmm0 + LONG $0xdfebe9c5 // vpor %xmm7, %xmm2, %xmm3 + LONG $0xc0ebf1c5 // vpor %xmm0, %xmm1, %xmm0 + LONG $0xc0ebe1c5 // vpor %xmm0, %xmm3, %xmm0 + LONG $0xd7d7f9c5 // vpmovmskb %xmm7, %edx + LONG $0xfad779c5 // vpmovmskb %xmm2, %r15d + LONG $0xf1d779c5 // vpmovmskb %xmm1, %r14d LONG $0xc8d7f9c5 // vpmovmskb %xmm0, %ecx - WORD $0xd1f7 // notl %ecx - WORD $0xbc0f; BYTE $0xc9 // bsfl %ecx, %ecx + WORD $0x314c; BYTE $0xd9 // xorq %r11, %rcx + LONG $0xc9bc0f48 // bsfq %rcx, %rcx WORD $0xf983; BYTE $0x10 // cmpl $16, %ecx - LONG $0x0014840f; WORD $0x0000 // je LBB27_11, $20(%rip) - LONG $0xffffffba; BYTE $0xff // movl $-1, %edx - WORD $0xe2d3 // shll %cl, %edx - WORD $0xd2f7 // notl %edx - WORD $0xd321 // andl %edx, %ebx - WORD $0x2141; BYTE $0xd6 // andl %edx, %r14d - WORD $0x2144; BYTE $0xda // andl %r11d, %edx - WORD $0x8941; BYTE $0xd3 // movl %edx, %r11d - -LBB27_11: - WORD $0x538d; BYTE $0xff // leal $-1(%rbx), %edx + LONG $0x0014840f; WORD $0x0000 // je LBB22_9, $20(%rip) + LONG $0xffffffbb; BYTE $0xff // movl $-1, %ebx + WORD $0xe3d3 // shll %cl, %ebx + WORD $0xd3f7 // notl %ebx WORD $0xda21 // andl %ebx, %edx - LONG $0x0206850f; WORD $0x0000 // jne LBB27_12, $518(%rip) - LONG $0xff568d41 // leal $-1(%r14), %edx - WORD $0x2144; BYTE $0xf2 // andl %r14d, %edx - LONG $0x01f9850f; WORD $0x0000 // jne LBB27_12, $505(%rip) - LONG $0xff538d41 // leal $-1(%r11), %edx - WORD $0x2144; BYTE $0xda // andl %r11d, %edx - LONG $0x01ec850f; WORD $0x0000 // jne LBB27_12, $492(%rip) - WORD $0xdb85 // testl %ebx, %ebx - LONG $0x0013840f; WORD $0x0000 // je LBB27_19, $19(%rip) - WORD $0xbc0f; BYTE $0xdb // bsfl %ebx, %ebx + WORD $0x2141; BYTE $0xdf // andl %ebx, %r15d + WORD $0x2144; BYTE $0xf3 // andl %r14d, %ebx + WORD $0x8941; BYTE $0xde // movl %ebx, %r14d + +LBB22_9: + WORD $0x5a8d; BYTE $0xff // leal $-1(%rdx), %ebx + WORD $0xd321 // andl %edx, %ebx + LONG $0x01fa850f; WORD $0x0000 // jne LBB22_50, $506(%rip) + LONG $0xff5f8d41 // leal $-1(%r15), %ebx + WORD $0x2144; BYTE $0xfb // andl %r15d, %ebx + LONG $0x01ed850f; WORD $0x0000 // jne LBB22_50, $493(%rip) + LONG $0xff5e8d41 // leal $-1(%r14), %ebx + WORD $0x2144; BYTE $0xf3 // andl %r14d, %ebx + LONG $0x01e0850f; WORD $0x0000 // jne LBB22_50, $480(%rip) + WORD $0xd285 // testl %edx, %edx + LONG $0x0019840f; WORD $0x0000 // je LBB22_15, $25(%rip) + WORD $0x894c; BYTE $0xd3 // movq %r10, %rbx + WORD $0x2948; BYTE $0xfb // subq %rdi, %rbx + WORD $0xbc0f; BYTE $0xd2 // bsfl %edx, %edx + WORD $0x0148; BYTE $0xda // addq %rbx, %rdx LONG $0xfff88349 // cmpq $-1, %r8 - LONG $0x01ed850f; WORD $0x0000 // jne LBB27_56, $493(%rip) - WORD $0x0148; BYTE $0xc3 // addq %rax, %rbx - WORD $0x8949; BYTE $0xd8 // movq %rbx, %r8 + LONG $0x01cb850f; WORD $0x0000 // jne LBB22_51, $459(%rip) + WORD $0x8949; BYTE $0xd0 // movq %rdx, %r8 + +LBB22_15: + WORD $0x8545; BYTE $0xff // testl %r15d, %r15d + LONG $0x001a840f; WORD $0x0000 // je LBB22_18, $26(%rip) + WORD $0x894c; BYTE $0xd3 // movq %r10, %rbx + WORD $0x2948; BYTE $0xfb // subq %rdi, %rbx + LONG $0xd7bc0f41 // bsfl %r15d, %edx + WORD $0x0148; BYTE $0xda // addq %rbx, %rdx + LONG $0xfff88348 // cmpq $-1, %rax + LONG $0x01a8850f; WORD $0x0000 // jne LBB22_51, $424(%rip) + WORD $0x8948; BYTE $0xd0 // movq %rdx, %rax -LBB27_19: +LBB22_18: WORD $0x8545; BYTE $0xf6 // testl %r14d, %r14d - LONG $0x0014840f; WORD $0x0000 // je LBB27_22, $20(%rip) - LONG $0xdebc0f41 // bsfl %r14d, %ebx + LONG $0x001a840f; WORD $0x0000 // je LBB22_21, $26(%rip) + WORD $0x894c; BYTE $0xd3 // movq %r10, %rbx + WORD $0x2948; BYTE $0xfb // subq %rdi, %rbx + LONG $0xd6bc0f41 // bsfl %r14d, %edx + WORD $0x0148; BYTE $0xda // addq %rbx, %rdx LONG $0xfff98349 // cmpq $-1, %r9 - LONG $0x01d0850f; WORD $0x0000 // jne LBB27_56, $464(%rip) - WORD $0x0148; BYTE $0xc3 // addq %rax, %rbx - WORD $0x8949; BYTE $0xd9 // movq %rbx, %r9 - -LBB27_22: - WORD $0x8545; BYTE $0xdb // testl %r11d, %r11d - LONG $0x0014840f; WORD $0x0000 // je LBB27_25, $20(%rip) - LONG $0xdbbc0f41 // bsfl %r11d, %ebx - LONG $0xfffa8349 // cmpq $-1, %r10 - LONG $0x01b3850f; WORD $0x0000 // jne LBB27_56, $435(%rip) - WORD $0x0148; BYTE $0xc3 // addq %rax, %rbx - WORD $0x8949; BYTE $0xda // movq %rbx, %r10 + LONG $0x0185850f; WORD $0x0000 // jne LBB22_51, $389(%rip) + WORD $0x8949; BYTE $0xd1 // movq %rdx, %r9 -LBB27_25: +LBB22_21: WORD $0xf983; BYTE $0x10 // cmpl $16, %ecx - LONG $0x00b9850f; WORD $0x0000 // jne LBB27_57, $185(%rip) - LONG $0xf0c78349 // addq $-16, %r15 - LONG $0x10c08348 // addq $16, %rax - LONG $0x0fff8349 // cmpq $15, %r15 - LONG $0xff04870f; WORD $0xffff // ja LBB27_9, $-252(%rip) - LONG $0x070c8d48 // leaq (%rdi,%rax), %rcx - WORD $0x8949; BYTE $0xcb // movq %rcx, %r11 - WORD $0x3948; BYTE $0xf0 // cmpq %rsi, %rax - LONG $0x00a0840f; WORD $0x0000 // je LBB27_41, $160(%rip) + LONG $0x00b7850f; WORD $0x0000 // jne LBB22_35, $183(%rip) + LONG $0x10c28349 // addq $16, %r10 + LONG $0xf0c68348 // addq $-16, %rsi + LONG $0x0ffe8348 // cmpq $15, %rsi + LONG $0xfeef870f; WORD $0xffff // ja LBB22_7, $-273(%rip) + WORD $0x8548; BYTE $0xf6 // testq %rsi, %rsi + LONG $0x009f840f; WORD $0x0000 // je LBB22_36, $159(%rip) -LBB27_28: - LONG $0x391c8d4e // leaq (%rcx,%r15), %r11 - WORD $0x8948; BYTE $0xce // movq %rcx, %rsi - WORD $0x2948; BYTE $0xfe // subq %rdi, %rsi - WORD $0xc031 // xorl %eax, %eax - LONG $0x9d358d4c; WORD $0x0001; BYTE $0x00 // leaq $413(%rip), %r14 /* LJTI27_0(%rip) */ - LONG $0x000028e9; BYTE $0x00 // jmp LBB27_29, $40(%rip) +LBB22_24: + LONG $0x321c8d4d // leaq (%r10,%rsi), %r11 + LONG $0x9f1d8d48; WORD $0x0001; BYTE $0x00 // leaq $415(%rip), %rbx /* LJTI22_0(%rip) */ + LONG $0x000012e9; BYTE $0x00 // jmp LBB22_26, $18(%rip) + LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 -LBB27_31: - WORD $0xfb83; BYTE $0x65 // cmpl $101, %ebx - LONG $0x0094850f; WORD $0x0000 // jne LBB27_40, $148(%rip) +LBB22_25: + WORD $0x8949; BYTE $0xca // movq %rcx, %r10 + WORD $0xff48; BYTE $0xce // decq %rsi + LONG $0x0149840f; WORD $0x0000 // je LBB22_54, $329(%rip) + +LBB22_26: + LONG $0x12be0f41 // movsbl (%r10), %edx + WORD $0xc283; BYTE $0xd5 // addl $-43, %edx + WORD $0xfa83; BYTE $0x3a // cmpl $58, %edx + LONG $0x006d870f; WORD $0x0000 // ja LBB22_36, $109(%rip) + LONG $0x014a8d49 // leaq $1(%r10), %rcx + LONG $0x93146348 // movslq (%rbx,%rdx,4), %rdx + WORD $0x0148; BYTE $0xda // addq %rbx, %rdx + JMP DX -LBB27_32: +LBB22_28: + WORD $0x8948; BYTE $0xca // movq %rcx, %rdx + WORD $0x2948; BYTE $0xfa // subq %rdi, %rdx LONG $0xfff98349 // cmpq $-1, %r9 - LONG $0x0149850f; WORD $0x0000 // jne LBB27_58, $329(%rip) - LONG $0x060c8d4c // leaq (%rsi,%rax), %r9 - LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 - -LBB27_39: - WORD $0xff48; BYTE $0xc0 // incq %rax - WORD $0x3949; BYTE $0xc7 // cmpq %rax, %r15 - LONG $0x0060840f; WORD $0x0000 // je LBB27_41, $96(%rip) - -LBB27_29: - LONG $0x011cbe0f // movsbl (%rcx,%rax), %ebx - WORD $0x538d; BYTE $0xd0 // leal $-48(%rbx), %edx - WORD $0xfa83; BYTE $0x0a // cmpl $10, %edx - LONG $0xffe4820f; WORD $0xffff // jb LBB27_39, $-28(%rip) - WORD $0x538d; BYTE $0xd5 // leal $-43(%rbx), %edx - WORD $0xfa83; BYTE $0x1a // cmpl $26, %edx - LONG $0xffbc870f; WORD $0xffff // ja LBB27_31, $-68(%rip) - LONG $0x96146349 // movslq (%r14,%rdx,4), %rdx - WORD $0x014c; BYTE $0xf2 // addq %r14, %rdx - JMP DX + LONG $0x0134850f; WORD $0x0000 // jne LBB22_58, $308(%rip) + WORD $0xff48; BYTE $0xca // decq %rdx + WORD $0x8949; BYTE $0xd1 // movq %rdx, %r9 + LONG $0xffffbce9; BYTE $0xff // jmp LBB22_25, $-68(%rip) -LBB27_37: - LONG $0xfffa8349 // cmpq $-1, %r10 - LONG $0x0105850f; WORD $0x0000 // jne LBB27_58, $261(%rip) - LONG $0x06148d4c // leaq (%rsi,%rax), %r10 - LONG $0xffffbce9; BYTE $0xff // jmp LBB27_39, $-68(%rip) +LBB22_30: + WORD $0x8948; BYTE $0xca // movq %rcx, %rdx + WORD $0x2948; BYTE $0xfa // subq %rdi, %rdx + LONG $0xfff88348 // cmpq $-1, %rax + LONG $0x0119850f; WORD $0x0000 // jne LBB22_58, $281(%rip) + WORD $0xff48; BYTE $0xca // decq %rdx + WORD $0x8948; BYTE $0xd0 // movq %rdx, %rax + LONG $0xffffa1e9; BYTE $0xff // jmp LBB22_25, $-95(%rip) -LBB27_35: +LBB22_32: + WORD $0x8948; BYTE $0xca // movq %rcx, %rdx + WORD $0x2948; BYTE $0xfa // subq %rdi, %rdx LONG $0xfff88349 // cmpq $-1, %r8 - LONG $0x00f2850f; WORD $0x0000 // jne LBB27_58, $242(%rip) - LONG $0x06048d4c // leaq (%rsi,%rax), %r8 - LONG $0xffffa9e9; BYTE $0xff // jmp LBB27_39, $-87(%rip) + LONG $0x00fe850f; WORD $0x0000 // jne LBB22_58, $254(%rip) + WORD $0xff48; BYTE $0xca // decq %rdx + WORD $0x8949; BYTE $0xd0 // movq %rdx, %r8 + LONG $0xffff86e9; BYTE $0xff // jmp LBB22_25, $-122(%rip) -LBB27_1: +LBB22_34: LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax - LONG $0x00008fe9; BYTE $0x00 // jmp LBB27_55, $143(%rip) - -LBB27_57: - WORD $0x8941; BYTE $0xcb // movl %ecx, %r11d - WORD $0x0149; BYTE $0xfb // addq %rdi, %r11 - WORD $0x0149; BYTE $0xc3 // addq %rax, %r11 + LONG $0x0000c8e9; BYTE $0x00 // jmp LBB22_53, $200(%rip) -LBB27_41: - LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax - WORD $0x854d; BYTE $0xc0 // testq %r8, %r8 - LONG $0x001b850f; WORD $0x0000 // jne LBB27_42, $27(%rip) - LONG $0x000071e9; BYTE $0x00 // jmp LBB27_55, $113(%rip) +LBB22_35: + WORD $0x0149; BYTE $0xca // addq %rcx, %r10 -LBB27_40: - WORD $0x0148; BYTE $0xc1 // addq %rax, %rcx - WORD $0x8949; BYTE $0xcb // movq %rcx, %r11 - LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax - WORD $0x854d; BYTE $0xc0 // testq %r8, %r8 - LONG $0x005b840f; WORD $0x0000 // je LBB27_55, $91(%rip) +LBB22_36: + LONG $0xffc2c748; WORD $0xffff; BYTE $0xff // movq $-1, %rdx + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0x00b2840f; WORD $0x0000 // je LBB22_52, $178(%rip) -LBB27_42: - WORD $0x854d; BYTE $0xd2 // testq %r10, %r10 - LONG $0x0052840f; WORD $0x0000 // je LBB27_55, $82(%rip) +LBB22_37: + WORD $0x854d; BYTE $0xc9 // testq %r9, %r9 + LONG $0x00a9840f; WORD $0x0000 // je LBB22_52, $169(%rip) + WORD $0x854d; BYTE $0xc0 // testq %r8, %r8 + LONG $0x00a0840f; WORD $0x0000 // je LBB22_52, $160(%rip) + WORD $0x2949; BYTE $0xfa // subq %rdi, %r10 + LONG $0xff4a8d49 // leaq $-1(%r10), %rcx + WORD $0x3948; BYTE $0xc8 // cmpq %rcx, %rax + LONG $0x0036840f; WORD $0x0000 // je LBB22_45, $54(%rip) + WORD $0x3949; BYTE $0xc8 // cmpq %rcx, %r8 + LONG $0x002d840f; WORD $0x0000 // je LBB22_45, $45(%rip) + WORD $0x3949; BYTE $0xc9 // cmpq %rcx, %r9 + LONG $0x0024840f; WORD $0x0000 // je LBB22_45, $36(%rip) WORD $0x854d; BYTE $0xc9 // testq %r9, %r9 - LONG $0x0049840f; WORD $0x0000 // je LBB27_55, $73(%rip) - WORD $0x2949; BYTE $0xfb // subq %rdi, %r11 - LONG $0xff438d49 // leaq $-1(%r11), %rax + LONG $0x00298e0f; WORD $0x0000 // jle LBB22_46, $41(%rip) + LONG $0xff498d49 // leaq $-1(%r9), %rcx + WORD $0x3948; BYTE $0xc8 // cmpq %rcx, %rax + LONG $0x001c840f; WORD $0x0000 // je LBB22_46, $28(%rip) + WORD $0xf749; BYTE $0xd1 // notq %r9 + WORD $0x894c; BYTE $0xca // movq %r9, %rdx + WORD $0x894c; BYTE $0xc8 // movq %r9, %rax + LONG $0x00005de9; BYTE $0x00 // jmp LBB22_53, $93(%rip) + +LBB22_45: + WORD $0xf749; BYTE $0xda // negq %r10 + WORD $0x894c; BYTE $0xd2 // movq %r10, %rdx + WORD $0x894c; BYTE $0xd0 // movq %r10, %rax + LONG $0x00004fe9; BYTE $0x00 // jmp LBB22_53, $79(%rip) + +LBB22_46: + WORD $0x894c; BYTE $0xc1 // movq %r8, %rcx + WORD $0x0948; BYTE $0xc1 // orq %rax, %rcx WORD $0x3949; BYTE $0xc0 // cmpq %rax, %r8 - LONG $0x0033840f; WORD $0x0000 // je LBB27_47, $51(%rip) - WORD $0x3949; BYTE $0xc2 // cmpq %rax, %r10 - LONG $0x002a840f; WORD $0x0000 // je LBB27_47, $42(%rip) - WORD $0x3949; BYTE $0xc1 // cmpq %rax, %r9 - LONG $0x0021840f; WORD $0x0000 // je LBB27_47, $33(%rip) - WORD $0x854d; BYTE $0xd2 // testq %r10, %r10 - LONG $0x00258e0f; WORD $0x0000 // jle LBB27_51, $37(%rip) - LONG $0xff428d49 // leaq $-1(%r10), %rax - WORD $0x3949; BYTE $0xc1 // cmpq %rax, %r9 - LONG $0x0018840f; WORD $0x0000 // je LBB27_51, $24(%rip) - WORD $0xf749; BYTE $0xd2 // notq %r10 - WORD $0x894c; BYTE $0xd0 // movq %r10, %rax - LONG $0x000006e9; BYTE $0x00 // jmp LBB27_55, $6(%rip) + LONG $0x00178c0f; WORD $0x0000 // jl LBB22_49, $23(%rip) + WORD $0x8548; BYTE $0xc9 // testq %rcx, %rcx + LONG $0x000e880f; WORD $0x0000 // js LBB22_49, $14(%rip) + WORD $0xf749; BYTE $0xd0 // notq %r8 + WORD $0x894c; BYTE $0xc2 // movq %r8, %rdx + WORD $0x894c; BYTE $0xc0 // movq %r8, %rax + LONG $0x000029e9; BYTE $0x00 // jmp LBB22_53, $41(%rip) -LBB27_47: - WORD $0xf749; BYTE $0xdb // negq %r11 - WORD $0x894c; BYTE $0xd8 // movq %r11, %rax +LBB22_49: + LONG $0xff508d48 // leaq $-1(%rax), %rdx + WORD $0x8548; BYTE $0xc9 // testq %rcx, %rcx + WORD $0xf748; BYTE $0xd0 // notq %rax + LONG $0xc2480f49 // cmovsq %r10, %rax + WORD $0x3949; BYTE $0xd0 // cmpq %rdx, %r8 + LONG $0xc2450f49 // cmovneq %r10, %rax + LONG $0x00000fe9; BYTE $0x00 // jmp LBB22_53, $15(%rip) -LBB27_55: +LBB22_50: + WORD $0x2949; BYTE $0xfa // subq %rdi, %r10 + WORD $0xbc0f; BYTE $0xd3 // bsfl %ebx, %edx + WORD $0x014c; BYTE $0xd2 // addq %r10, %rdx + +LBB22_51: + WORD $0xf748; BYTE $0xd2 // notq %rdx + +LBB22_52: + WORD $0x8948; BYTE $0xd0 // movq %rdx, %rax + +LBB22_53: BYTE $0x5b // popq %rbx WORD $0x5e41 // popq %r14 WORD $0x5f41 // popq %r15 BYTE $0x5d // popq %rbp BYTE $0xc3 // retq -LBB27_51: - WORD $0x894c; BYTE $0xc0 // movq %r8, %rax - WORD $0x094c; BYTE $0xc8 // orq %r9, %rax - WORD $0x990f; BYTE $0xc0 // setns %al - LONG $0x0014880f; WORD $0x0000 // js LBB27_54, $20(%rip) - WORD $0x394d; BYTE $0xc8 // cmpq %r9, %r8 - LONG $0x000b8c0f; WORD $0x0000 // jl LBB27_54, $11(%rip) - WORD $0xf749; BYTE $0xd0 // notq %r8 - WORD $0x894c; BYTE $0xc0 // movq %r8, %rax - LONG $0xffffd6e9; BYTE $0xff // jmp LBB27_55, $-42(%rip) - -LBB27_54: - LONG $0xff498d49 // leaq $-1(%r9), %rcx - WORD $0x3949; BYTE $0xc8 // cmpq %rcx, %r8 - WORD $0xf749; BYTE $0xd1 // notq %r9 - LONG $0xcb450f4d // cmovneq %r11, %r9 - WORD $0xc084 // testb %al, %al - LONG $0xcb440f4d // cmoveq %r11, %r9 - WORD $0x894c; BYTE $0xc8 // movq %r9, %rax - LONG $0xffffbae9; BYTE $0xff // jmp LBB27_55, $-70(%rip) - -LBB27_12: - WORD $0xbc0f; BYTE $0xca // bsfl %edx, %ecx - LONG $0x000010e9; BYTE $0x00 // jmp LBB27_13, $16(%rip) - -LBB27_58: - WORD $0x2948; BYTE $0xcf // subq %rcx, %rdi - WORD $0xf748; BYTE $0xd0 // notq %rax - WORD $0x0148; BYTE $0xf8 // addq %rdi, %rax - LONG $0xffffa4e9; BYTE $0xff // jmp LBB27_55, $-92(%rip) - -LBB27_56: - WORD $0xd989 // movl %ebx, %ecx +LBB22_54: + WORD $0x894d; BYTE $0xda // movq %r11, %r10 + LONG $0xffc2c748; WORD $0xffff; BYTE $0xff // movq $-1, %rdx + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0xff31850f; WORD $0xffff // jne LBB22_37, $-207(%rip) + LONG $0xffffdee9; BYTE $0xff // jmp LBB22_52, $-34(%rip) -LBB27_13: - WORD $0xf748; BYTE $0xd0 // notq %rax - WORD $0x2948; BYTE $0xc8 // subq %rcx, %rax - LONG $0xffff97e9; BYTE $0xff // jmp LBB27_55, $-105(%rip) +LBB22_58: + WORD $0xf748; BYTE $0xda // negq %rdx + LONG $0xffffd6e9; BYTE $0xff // jmp LBB22_52, $-42(%rip) -LBB27_7: +LBB22_57: LONG $0xffc0c749; WORD $0xffff; BYTE $0xff // movq $-1, %r8 - WORD $0x8948; BYTE $0xf9 // movq %rdi, %rcx - WORD $0x8949; BYTE $0xf7 // movq %rsi, %r15 + WORD $0x8949; BYTE $0xfa // movq %rdi, %r10 + LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax LONG $0xffc1c749; WORD $0xffff; BYTE $0xff // movq $-1, %r9 - LONG $0xffc2c749; WORD $0xffff; BYTE $0xff // movq $-1, %r10 - LONG $0xfffe51e9; BYTE $0xff // jmp LBB27_28, $-431(%rip) - BYTE $0x90 // .p2align 2, 0x90 - - // .set L27_0_set_37, LBB27_37-LJTI27_0 - // .set L27_0_set_40, LBB27_40-LJTI27_0 - // .set L27_0_set_35, LBB27_35-LJTI27_0 - // .set L27_0_set_32, LBB27_32-LJTI27_0 -LJTI27_0: - LONG $0xfffffeb5 // .long L27_0_set_37 - LONG $0xffffff05 // .long L27_0_set_40 - LONG $0xfffffeb5 // .long L27_0_set_37 - LONG $0xfffffec8 // .long L27_0_set_35 - LONG $0xffffff05 // .long L27_0_set_40 - LONG $0xffffff05 // .long L27_0_set_40 - LONG $0xffffff05 // .long L27_0_set_40 - LONG $0xffffff05 // .long L27_0_set_40 - LONG $0xffffff05 // .long L27_0_set_40 - LONG $0xffffff05 // .long L27_0_set_40 - LONG $0xffffff05 // .long L27_0_set_40 - LONG $0xffffff05 // .long L27_0_set_40 - LONG $0xffffff05 // .long L27_0_set_40 - LONG $0xffffff05 // .long L27_0_set_40 - LONG $0xffffff05 // .long L27_0_set_40 - LONG $0xffffff05 // .long L27_0_set_40 - LONG $0xffffff05 // .long L27_0_set_40 - LONG $0xffffff05 // .long L27_0_set_40 - LONG $0xffffff05 // .long L27_0_set_40 - LONG $0xffffff05 // .long L27_0_set_40 - LONG $0xffffff05 // .long L27_0_set_40 - LONG $0xffffff05 // .long L27_0_set_40 - LONG $0xffffff05 // .long L27_0_set_40 - LONG $0xffffff05 // .long L27_0_set_40 - LONG $0xffffff05 // .long L27_0_set_40 - LONG $0xffffff05 // .long L27_0_set_40 - LONG $0xfffffe71 // .long L27_0_set_32 - QUAD $0x9090909090909090 // .p2align 4, 0x90 + LONG $0xfffe58e9; BYTE $0xff // jmp LBB22_24, $-424(%rip) + WORD $0x9090 // .p2align 2, 0x90 + + // .set L22_0_set_28, LBB22_28-LJTI22_0 + // .set L22_0_set_36, LBB22_36-LJTI22_0 + // .set L22_0_set_32, LBB22_32-LJTI22_0 + // .set L22_0_set_25, LBB22_25-LJTI22_0 + // .set L22_0_set_30, LBB22_30-LJTI22_0 +LJTI22_0: + LONG $0xfffffe95 // .long L22_0_set_28 + LONG $0xfffffef5 // .long L22_0_set_36 + LONG $0xfffffe95 // .long L22_0_set_28 + LONG $0xfffffecb // .long L22_0_set_32 + LONG $0xfffffef5 // .long L22_0_set_36 + LONG $0xfffffe6c // .long L22_0_set_25 + LONG $0xfffffe6c // .long L22_0_set_25 + LONG $0xfffffe6c // .long L22_0_set_25 + LONG $0xfffffe6c // .long L22_0_set_25 + LONG $0xfffffe6c // .long L22_0_set_25 + LONG $0xfffffe6c // .long L22_0_set_25 + LONG $0xfffffe6c // .long L22_0_set_25 + LONG $0xfffffe6c // .long L22_0_set_25 + LONG $0xfffffe6c // .long L22_0_set_25 + LONG $0xfffffe6c // .long L22_0_set_25 + LONG $0xfffffef5 // .long L22_0_set_36 + LONG $0xfffffef5 // .long L22_0_set_36 + LONG $0xfffffef5 // .long L22_0_set_36 + LONG $0xfffffef5 // .long L22_0_set_36 + LONG $0xfffffef5 // .long L22_0_set_36 + LONG $0xfffffef5 // .long L22_0_set_36 + LONG $0xfffffef5 // .long L22_0_set_36 + LONG $0xfffffef5 // .long L22_0_set_36 + LONG $0xfffffef5 // .long L22_0_set_36 + LONG $0xfffffef5 // .long L22_0_set_36 + LONG $0xfffffef5 // .long L22_0_set_36 + LONG $0xfffffeb0 // .long L22_0_set_30 + LONG $0xfffffef5 // .long L22_0_set_36 + LONG $0xfffffef5 // .long L22_0_set_36 + LONG $0xfffffef5 // .long L22_0_set_36 + LONG $0xfffffef5 // .long L22_0_set_36 + LONG $0xfffffef5 // .long L22_0_set_36 + LONG $0xfffffef5 // .long L22_0_set_36 + LONG $0xfffffef5 // .long L22_0_set_36 + LONG $0xfffffef5 // .long L22_0_set_36 + LONG $0xfffffef5 // .long L22_0_set_36 + LONG $0xfffffef5 // .long L22_0_set_36 + LONG $0xfffffef5 // .long L22_0_set_36 + LONG $0xfffffef5 // .long L22_0_set_36 + LONG $0xfffffef5 // .long L22_0_set_36 + LONG $0xfffffef5 // .long L22_0_set_36 + LONG $0xfffffef5 // .long L22_0_set_36 + LONG $0xfffffef5 // .long L22_0_set_36 + LONG $0xfffffef5 // .long L22_0_set_36 + LONG $0xfffffef5 // .long L22_0_set_36 + LONG $0xfffffef5 // .long L22_0_set_36 + LONG $0xfffffef5 // .long L22_0_set_36 + LONG $0xfffffef5 // .long L22_0_set_36 + LONG $0xfffffef5 // .long L22_0_set_36 + LONG $0xfffffef5 // .long L22_0_set_36 + LONG $0xfffffef5 // .long L22_0_set_36 + LONG $0xfffffef5 // .long L22_0_set_36 + LONG $0xfffffef5 // .long L22_0_set_36 + LONG $0xfffffef5 // .long L22_0_set_36 + LONG $0xfffffef5 // .long L22_0_set_36 + LONG $0xfffffef5 // .long L22_0_set_36 + LONG $0xfffffef5 // .long L22_0_set_36 + LONG $0xfffffef5 // .long L22_0_set_36 + LONG $0xfffffeb0 // .long L22_0_set_30 + // .p2align 4, 0x90 _skip_positive: BYTE $0x55 // pushq %rbp WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp @@ -6938,7 +6376,7 @@ _skip_positive: LONG $0x08778b48 // movq $8(%rdi), %rsi WORD $0x2948; BYTE $0xde // subq %rbx, %rsi WORD $0x8948; BYTE $0xc7 // movq %rax, %rdi - LONG $0xfffbf7e8; BYTE $0xff // callq _do_skip_number, $-1033(%rip) + LONG $0xfffb77e8; BYTE $0xff // callq _do_skip_number, $-1161(%rip) LONG $0xff508d48 // leaq $-1(%rax), %rdx LONG $0xfec1c748; WORD $0xffff; BYTE $0xff // movq $-2, %rcx LONG $0xfec6c748; WORD $0xffff; BYTE $0xff // movq $-2, %rsi @@ -6974,22 +6412,22 @@ _skip_number: WORD $0x940f; BYTE $0xc0 // sete %al WORD $0x0148; BYTE $0xc3 // addq %rax, %rbx WORD $0x2948; BYTE $0xc6 // subq %rax, %rsi - LONG $0x003c840f; WORD $0x0000 // je LBB29_6, $60(%rip) + LONG $0x003b840f; WORD $0x0000 // je LBB24_6, $59(%rip) WORD $0x3949; BYTE $0xf7 // cmpq %rsi, %r15 - LONG $0x000d830f; WORD $0x0000 // jae LBB29_3, $13(%rip) - WORD $0xb60f; BYTE $0x03 // movzbl (%rbx), %eax - WORD $0xc604 // addb $-58, %al - WORD $0xf63c // cmpb $-10, %al - LONG $0x0038820f; WORD $0x0000 // jb LBB29_8, $56(%rip) + LONG $0x000c830f; WORD $0x0000 // jae LBB24_3, $12(%rip) + WORD $0x038a // movb (%rbx), %al + WORD $0xd004 // addb $-48, %al + WORD $0x093c // cmpb $9, %al + LONG $0x0038870f; WORD $0x0000 // ja LBB24_8, $56(%rip) -LBB29_3: +LBB24_3: WORD $0x8948; BYTE $0xdf // movq %rbx, %rdi - LONG $0xfffb70e8; BYTE $0xff // callq _do_skip_number, $-1168(%rip) + LONG $0xfffaf1e8; BYTE $0xff // callq _do_skip_number, $-1295(%rip) WORD $0x8548; BYTE $0xc0 // testq %rax, %rax - LONG $0x0021880f; WORD $0x0000 // js LBB29_7, $33(%rip) + LONG $0x0021880f; WORD $0x0000 // js LBB24_7, $33(%rip) WORD $0x0148; BYTE $0xc3 // addq %rax, %rbx -LBB29_5: +LBB24_5: WORD $0x294c; BYTE $0xe3 // subq %r12, %rbx WORD $0x8949; BYTE $0x1e // movq %rbx, (%r14) WORD $0x894c; BYTE $0xf8 // movq %r15, %rax @@ -7000,20 +6438,20 @@ LBB29_5: BYTE $0x5d // popq %rbp BYTE $0xc3 // retq -LBB29_6: +LBB24_6: LONG $0xffc7c749; WORD $0xffff; BYTE $0xff // movq $-1, %r15 - LONG $0xffffe2e9; BYTE $0xff // jmp LBB29_5, $-30(%rip) + LONG $0xffffe2e9; BYTE $0xff // jmp LBB24_5, $-30(%rip) -LBB29_7: +LBB24_7: WORD $0xf748; BYTE $0xd0 // notq %rax WORD $0x0148; BYTE $0xc3 // addq %rax, %rbx -LBB29_8: +LBB24_8: LONG $0xfec7c749; WORD $0xffff; BYTE $0xff // movq $-2, %r15 - LONG $0xffffd0e9; BYTE $0xff // jmp LBB29_5, $-48(%rip) - LONG $0x00000000 // .p2align 4, 0x00 + LONG $0xffffd0e9; BYTE $0xff // jmp LBB24_5, $-48(%rip) + LONG $0x00000000; BYTE $0x00 // .p2align 4, 0x00 -LCPI30_0: +LCPI25_0: LONG $0x00000001 // .long 1 LONG $0x00000000 // .long 0 LONG $0x00000000 // .long 0 @@ -7026,14 +6464,14 @@ _skip_one: WORD $0x8948; BYTE $0xd0 // movq %rdx, %rax WORD $0x8948; BYTE $0xf2 // movq %rsi, %rdx WORD $0x8948; BYTE $0xfe // movq %rdi, %rsi - QUAD $0xffffffdb0528f8c5 // vmovaps $-37(%rip), %xmm0 /* LCPI30_0(%rip) */ + QUAD $0xffffffdb0528f8c5 // vmovaps $-37(%rip), %xmm0 /* LCPI25_0(%rip) */ LONG $0x0011f8c5 // vmovups %xmm0, (%rax) WORD $0x8948; BYTE $0xc7 // movq %rax, %rdi BYTE $0x5d // popq %rbp - LONG $0xfff25ee9; BYTE $0xff // jmp _fsm_exec, $-3490(%rip) + LONG $0xffefcee9; BYTE $0xff // jmp _fsm_exec, $-4146(%rip) QUAD $0x0000000000000000; LONG $0x00000000; WORD $0x0000 // .p2align 4, 0x00 -LCPI31_0: +LCPI26_0: LONG $0x00000001 // .long 1 LONG $0x00000000 // .long 0 LONG $0x00000000 // .long 0 @@ -7046,36 +6484,36 @@ _validate_one: WORD $0x8948; BYTE $0xd0 // movq %rdx, %rax WORD $0x8948; BYTE $0xf2 // movq %rsi, %rdx WORD $0x8948; BYTE $0xfe // movq %rdi, %rsi - QUAD $0xffffffdb0528f8c5 // vmovaps $-37(%rip), %xmm0 /* LCPI31_0(%rip) */ + QUAD $0xffffffdb0528f8c5 // vmovaps $-37(%rip), %xmm0 /* LCPI26_0(%rip) */ LONG $0x0011f8c5 // vmovups %xmm0, (%rax) LONG $0x000020b9; BYTE $0x00 // movl $32, %ecx WORD $0x8948; BYTE $0xc7 // movq %rax, %rdi BYTE $0x5d // popq %rbp - LONG $0xfff219e9; BYTE $0xff // jmp _fsm_exec, $-3559(%rip) + LONG $0xffef89e9; BYTE $0xff // jmp _fsm_exec, $-4215(%rip) QUAD $0x0000000000000000; BYTE $0x00 // .p2align 4, 0x00 -LCPI32_0: +LCPI27_0: QUAD $0x2c2c2c2c2c2c2c2c; QUAD $0x2c2c2c2c2c2c2c2c // .space 16, ',,,,,,,,,,,,,,,,' -LCPI32_1: +LCPI27_1: QUAD $0xdfdfdfdfdfdfdfdf; QUAD $0xdfdfdfdfdfdfdfdf // .space 16, '\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf' -LCPI32_2: +LCPI27_2: QUAD $0x5d5d5d5d5d5d5d5d; QUAD $0x5d5d5d5d5d5d5d5d // .space 16, ']]]]]]]]]]]]]]]]' -LCPI32_3: +LCPI27_3: QUAD $0x2222222222222222; QUAD $0x2222222222222222 // .space 16, '""""""""""""""""' -LCPI32_4: +LCPI27_4: QUAD $0x5c5c5c5c5c5c5c5c; QUAD $0x5c5c5c5c5c5c5c5c // .space 16, '\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' -LCPI32_5: +LCPI27_5: QUAD $0x7b7b7b7b7b7b7b7b; QUAD $0x7b7b7b7b7b7b7b7b // .space 16, '{{{{{{{{{{{{{{{{' -LCPI32_6: +LCPI27_6: QUAD $0x7d7d7d7d7d7d7d7d; QUAD $0x7d7d7d7d7d7d7d7d // .space 16, '}}}}}}}}}}}}}}}}' -LCPI32_7: +LCPI27_7: QUAD $0x5b5b5b5b5b5b5b5b; QUAD $0x5b5b5b5b5b5b5b5b // .space 16, '[[[[[[[[[[[[[[[[' // .p2align 4, 0x90 @@ -7089,90 +6527,181 @@ _skip_one_fast: BYTE $0x53 // pushq %rbx LONG $0xe0e48348 // andq $-32, %rsp LONG $0x80ec8148; WORD $0x0000; BYTE $0x00 // subq $128, %rsp - WORD $0x8949; BYTE $0xf6 // movq %rsi, %r14 - WORD $0x8949; BYTE $0xff // movq %rdi, %r15 - WORD $0x8b48; BYTE $0x3f // movq (%rdi), %rdi - LONG $0x08778b49 // movq $8(%r15), %rsi - WORD $0x894c; BYTE $0xf2 // movq %r14, %rdx - LONG $0xffe043e8; BYTE $0xff // callq _advance_ns, $-8125(%rip) - WORD $0x8b49; BYTE $0x16 // movq (%r14), %rdx - LONG $0xff528d4c // leaq $-1(%rdx), %r10 - WORD $0xbe0f; BYTE $0xc8 // movsbl %al, %ecx + WORD $0x8b4c; BYTE $0x37 // movq (%rdi), %r14 + LONG $0x08478b4c // movq $8(%rdi), %r8 + WORD $0x8b48; BYTE $0x16 // movq (%rsi), %rdx + WORD $0x8948; BYTE $0xd0 // movq %rdx, %rax + WORD $0x294c; BYTE $0xc0 // subq %r8, %rax + LONG $0x002a830f; WORD $0x0000 // jae LBB27_5, $42(%rip) + LONG $0x160c8a41 // movb (%r14,%rdx), %cl + WORD $0xf980; BYTE $0x0d // cmpb $13, %cl + LONG $0x001d840f; WORD $0x0000 // je LBB27_5, $29(%rip) + WORD $0xf980; BYTE $0x20 // cmpb $32, %cl + LONG $0x0014840f; WORD $0x0000 // je LBB27_5, $20(%rip) + WORD $0xc180; BYTE $0xf7 // addb $-9, %cl + WORD $0xf980; BYTE $0x01 // cmpb $1, %cl + LONG $0x0008860f; WORD $0x0000 // jbe LBB27_5, $8(%rip) + WORD $0x8949; BYTE $0xd3 // movq %rdx, %r11 + LONG $0x000137e9; BYTE $0x00 // jmp LBB27_27, $311(%rip) + +LBB27_5: + LONG $0x015a8d4c // leaq $1(%rdx), %r11 + WORD $0x394d; BYTE $0xc3 // cmpq %r8, %r11 + LONG $0x0022830f; WORD $0x0000 // jae LBB27_9, $34(%rip) + LONG $0x1e0c8a43 // movb (%r14,%r11), %cl + WORD $0xf980; BYTE $0x0d // cmpb $13, %cl + LONG $0x0015840f; WORD $0x0000 // je LBB27_9, $21(%rip) + WORD $0xf980; BYTE $0x20 // cmpb $32, %cl + LONG $0x000c840f; WORD $0x0000 // je LBB27_9, $12(%rip) + WORD $0xc180; BYTE $0xf7 // addb $-9, %cl + WORD $0xf980; BYTE $0x01 // cmpb $1, %cl + LONG $0x0108870f; WORD $0x0000 // ja LBB27_27, $264(%rip) + +LBB27_9: + LONG $0x025a8d4c // leaq $2(%rdx), %r11 + WORD $0x394d; BYTE $0xc3 // cmpq %r8, %r11 + LONG $0x0022830f; WORD $0x0000 // jae LBB27_13, $34(%rip) + LONG $0x1e0c8a43 // movb (%r14,%r11), %cl + WORD $0xf980; BYTE $0x0d // cmpb $13, %cl + LONG $0x0015840f; WORD $0x0000 // je LBB27_13, $21(%rip) + WORD $0xf980; BYTE $0x20 // cmpb $32, %cl + LONG $0x000c840f; WORD $0x0000 // je LBB27_13, $12(%rip) + WORD $0xc180; BYTE $0xf7 // addb $-9, %cl + WORD $0xf980; BYTE $0x01 // cmpb $1, %cl + LONG $0x00d9870f; WORD $0x0000 // ja LBB27_27, $217(%rip) + +LBB27_13: + LONG $0x035a8d4c // leaq $3(%rdx), %r11 + WORD $0x394d; BYTE $0xc3 // cmpq %r8, %r11 + LONG $0x0022830f; WORD $0x0000 // jae LBB27_17, $34(%rip) + LONG $0x1e0c8a43 // movb (%r14,%r11), %cl + WORD $0xf980; BYTE $0x0d // cmpb $13, %cl + LONG $0x0015840f; WORD $0x0000 // je LBB27_17, $21(%rip) + WORD $0xf980; BYTE $0x20 // cmpb $32, %cl + LONG $0x000c840f; WORD $0x0000 // je LBB27_17, $12(%rip) + WORD $0xc180; BYTE $0xf7 // addb $-9, %cl + WORD $0xf980; BYTE $0x01 // cmpb $1, %cl + LONG $0x00aa870f; WORD $0x0000 // ja LBB27_27, $170(%rip) + +LBB27_17: + LONG $0x044a8d48 // leaq $4(%rdx), %rcx + WORD $0x3949; BYTE $0xc8 // cmpq %rcx, %r8 + LONG $0x0057860f; WORD $0x0000 // jbe LBB27_23, $87(%rip) + WORD $0x3949; BYTE $0xc8 // cmpq %rcx, %r8 + LONG $0x005d840f; WORD $0x0000 // je LBB27_24, $93(%rip) + LONG $0x060c8d4b // leaq (%r14,%r8), %rcx + LONG $0x04c08348 // addq $4, %rax + LONG $0x325c8d4e; BYTE $0x05 // leaq $5(%rdx,%r14), %r11 + QUAD $0x000100002600ba48; WORD $0x0000 // movabsq $4294977024, %rdx + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 + +LBB27_20: + LONG $0x5bbe0f41; BYTE $0xff // movsbl $-1(%r11), %ebx + WORD $0xfb83; BYTE $0x20 // cmpl $32, %ebx + LONG $0x0048870f; WORD $0x0000 // ja LBB27_26, $72(%rip) + LONG $0xdaa30f48 // btq %rbx, %rdx + LONG $0x003e830f; WORD $0x0000 // jae LBB27_26, $62(%rip) + WORD $0xff49; BYTE $0xc3 // incq %r11 + WORD $0xff48; BYTE $0xc0 // incq %rax + LONG $0xffdc850f; WORD $0xffff // jne LBB27_20, $-36(%rip) + LONG $0x000012e9; BYTE $0x00 // jmp LBB27_25, $18(%rip) + +LBB27_23: + WORD $0x8948; BYTE $0x0e // movq %rcx, (%rsi) + LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax + LONG $0x000120e9; BYTE $0x00 // jmp LBB27_44, $288(%rip) + +LBB27_24: + WORD $0x014c; BYTE $0xf1 // addq %r14, %rcx + +LBB27_25: + WORD $0x294c; BYTE $0xf1 // subq %r14, %rcx + WORD $0x8949; BYTE $0xcb // movq %rcx, %r11 + LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax + WORD $0x394d; BYTE $0xc3 // cmpq %r8, %r11 + LONG $0x001e820f; WORD $0x0000 // jb LBB27_27, $30(%rip) + LONG $0x000102e9; BYTE $0x00 // jmp LBB27_44, $258(%rip) + +LBB27_26: + WORD $0x894c; BYTE $0xf0 // movq %r14, %rax + WORD $0xf748; BYTE $0xd0 // notq %rax + WORD $0x0149; BYTE $0xc3 // addq %rax, %r11 + LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax + WORD $0x394d; BYTE $0xc3 // cmpq %r8, %r11 + LONG $0x00e9830f; WORD $0x0000 // jae LBB27_44, $233(%rip) + +LBB27_27: + LONG $0x015b8d49 // leaq $1(%r11), %rbx + WORD $0x8948; BYTE $0x1e // movq %rbx, (%rsi) + LONG $0x0cbe0f43; BYTE $0x1e // movsbl (%r14,%r11), %ecx WORD $0xf983; BYTE $0x7b // cmpl $123, %ecx - LONG $0x0111870f; WORD $0x0000 // ja LBB32_18, $273(%rip) + LONG $0x00f9870f; WORD $0x0000 // ja LBB27_46, $249(%rip) LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax - LONG $0xd6358d48; WORD $0x0009; BYTE $0x00 // leaq $2518(%rip), %rsi /* LJTI32_0(%rip) */ - LONG $0x8e0c6348 // movslq (%rsi,%rcx,4), %rcx - WORD $0x0148; BYTE $0xf1 // addq %rsi, %rcx + LONG $0xf6158d48; WORD $0x0009; BYTE $0x00 // leaq $2550(%rip), %rdx /* LJTI27_0(%rip) */ + LONG $0x8a0c6348 // movslq (%rdx,%rcx,4), %rcx + WORD $0x0148; BYTE $0xd1 // addq %rdx, %rcx JMP CX -LBB32_2: - WORD $0x8b49; BYTE $0x07 // movq (%r15), %rax - LONG $0x08778b49 // movq $8(%r15), %rsi - WORD $0x8948; BYTE $0xf1 // movq %rsi, %rcx - WORD $0x2948; BYTE $0xd1 // subq %rdx, %rcx - LONG $0x10f98348 // cmpq $16, %rcx - LONG $0x0909820f; WORD $0x0000 // jb LBB32_82, $2313(%rip) - WORD $0x8948; BYTE $0xd1 // movq %rdx, %rcx - WORD $0xf748; BYTE $0xd9 // negq %rcx - QUAD $0xffffff04056ff9c5 // vmovdqa $-252(%rip), %xmm0 /* LCPI32_0(%rip) */ - QUAD $0xffffff0c0d6ff9c5 // vmovdqa $-244(%rip), %xmm1 /* LCPI32_1(%rip) */ - QUAD $0xffffff14156ff9c5 // vmovdqa $-236(%rip), %xmm2 /* LCPI32_2(%rip) */ - LONG $0x90909090 // .p2align 4, 0x90 +LBB27_29: + LONG $0x08478b48 // movq $8(%rdi), %rax + WORD $0x2948; BYTE $0xd8 // subq %rbx, %rax + WORD $0x014c; BYTE $0xf3 // addq %r14, %rbx + LONG $0x10f88348 // cmpq $16, %rax + LONG $0x0054820f; WORD $0x0000 // jb LBB27_33, $84(%rip) + QUAD $0xfffffda9056ff9c5 // vmovdqa $-599(%rip), %xmm0 /* LCPI27_0(%rip) */ + QUAD $0xfffffdb10d6ff9c5 // vmovdqa $-591(%rip), %xmm1 /* LCPI27_1(%rip) */ + QUAD $0xfffffdb9156ff9c5 // vmovdqa $-583(%rip), %xmm2 /* LCPI27_2(%rip) */ + QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90 -LBB32_4: - LONG $0x1c6ffac5; BYTE $0x10 // vmovdqu (%rax,%rdx), %xmm3 +LBB27_31: + LONG $0x1b6ffac5 // vmovdqu (%rbx), %xmm3 LONG $0xe074e1c5 // vpcmpeqb %xmm0, %xmm3, %xmm4 LONG $0xd9dbe1c5 // vpand %xmm1, %xmm3, %xmm3 LONG $0xda74e1c5 // vpcmpeqb %xmm2, %xmm3, %xmm3 LONG $0xdcebe1c5 // vpor %xmm4, %xmm3, %xmm3 - LONG $0xfbd7f9c5 // vpmovmskb %xmm3, %edi - WORD $0xff85 // testl %edi, %edi - LONG $0x006b850f; WORD $0x0000 // jne LBB32_14, $107(%rip) - LONG $0x10c28348 // addq $16, %rdx - LONG $0x0e3c8d48 // leaq (%rsi,%rcx), %rdi - LONG $0xf0c78348 // addq $-16, %rdi - LONG $0xf0c18348 // addq $-16, %rcx - LONG $0x0fff8348 // cmpq $15, %rdi - LONG $0xffc5870f; WORD $0xffff // ja LBB32_4, $-59(%rip) - WORD $0x8948; BYTE $0xc2 // movq %rax, %rdx - WORD $0x2948; BYTE $0xca // subq %rcx, %rdx - WORD $0x0148; BYTE $0xce // addq %rcx, %rsi - WORD $0x8948; BYTE $0xf1 // movq %rsi, %rcx - WORD $0x8548; BYTE $0xc9 // testq %rcx, %rcx - LONG $0x0034840f; WORD $0x0000 // je LBB32_13, $52(%rip) + LONG $0xcbd7f9c5 // vpmovmskb %xmm3, %ecx + WORD $0x8566; BYTE $0xc9 // testw %cx, %cx + LONG $0x0054850f; WORD $0x0000 // jne LBB27_41, $84(%rip) + LONG $0x10c38348 // addq $16, %rbx + LONG $0xf0c08348 // addq $-16, %rax + LONG $0x0ff88348 // cmpq $15, %rax + LONG $0xffcd870f; WORD $0xffff // ja LBB27_31, $-51(%rip) -LBB32_7: - LONG $0x0a3c8d48 // leaq (%rdx,%rcx), %rdi - WORD $0xf631 // xorl %esi, %esi +LBB27_33: + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0x0031840f; WORD $0x0000 // je LBB27_40, $49(%rip) + LONG $0x030c8d48 // leaq (%rbx,%rax), %rcx -LBB32_8: - LONG $0x321cb60f // movzbl (%rdx,%rsi), %ebx - WORD $0xfb83; BYTE $0x2c // cmpl $44, %ebx - LONG $0x0859840f; WORD $0x0000 // je LBB32_80, $2137(%rip) - WORD $0xfb83; BYTE $0x7d // cmpl $125, %ebx - LONG $0x0850840f; WORD $0x0000 // je LBB32_80, $2128(%rip) - WORD $0xfb83; BYTE $0x5d // cmpl $93, %ebx - LONG $0x0847840f; WORD $0x0000 // je LBB32_80, $2119(%rip) - WORD $0xff48; BYTE $0xc6 // incq %rsi - WORD $0x3948; BYTE $0xf1 // cmpq %rsi, %rcx - LONG $0xffd5850f; WORD $0xffff // jne LBB32_8, $-43(%rip) - WORD $0x8948; BYTE $0xfa // movq %rdi, %rdx +LBB27_35: + WORD $0xb60f; BYTE $0x13 // movzbl (%rbx), %edx + WORD $0xfa80; BYTE $0x2c // cmpb $44, %dl + LONG $0x0021840f; WORD $0x0000 // je LBB27_40, $33(%rip) + WORD $0xfa80; BYTE $0x7d // cmpb $125, %dl + LONG $0x0018840f; WORD $0x0000 // je LBB27_40, $24(%rip) + WORD $0xfa80; BYTE $0x5d // cmpb $93, %dl + LONG $0x000f840f; WORD $0x0000 // je LBB27_40, $15(%rip) + WORD $0xff48; BYTE $0xc3 // incq %rbx + WORD $0xff48; BYTE $0xc8 // decq %rax + LONG $0xffd6850f; WORD $0xffff // jne LBB27_35, $-42(%rip) + WORD $0x8948; BYTE $0xcb // movq %rcx, %rbx -LBB32_13: - WORD $0x2948; BYTE $0xc2 // subq %rax, %rdx - LONG $0x000836e9; BYTE $0x00 // jmp LBB32_81, $2102(%rip) +LBB27_40: + WORD $0x294c; BYTE $0xf3 // subq %r14, %rbx + LONG $0x00000de9; BYTE $0x00 // jmp LBB27_42, $13(%rip) -LBB32_14: - LONG $0xc7bc0f66 // bsfw %di, %ax - WORD $0xb70f; BYTE $0xc0 // movzwl %ax, %eax - WORD $0x2948; BYTE $0xc8 // subq %rcx, %rax - WORD $0x8949; BYTE $0x06 // movq %rax, (%r14) +LBB27_41: + WORD $0xb70f; BYTE $0xc1 // movzwl %cx, %eax + LONG $0xc0bc0f48 // bsfq %rax, %rax + WORD $0x294c; BYTE $0xf3 // subq %r14, %rbx + WORD $0x0148; BYTE $0xc3 // addq %rax, %rbx -LBB32_15: - WORD $0x894c; BYTE $0xd0 // movq %r10, %rax +LBB27_42: + WORD $0x8948; BYTE $0x1e // movq %rbx, (%rsi) -LBB32_16: +LBB27_43: + WORD $0x894c; BYTE $0xd8 // movq %r11, %rax + +LBB27_44: LONG $0xd8658d48 // leaq $-40(%rbp), %rsp BYTE $0x5b // popq %rbx WORD $0x5c41 // popq %r12 @@ -7183,50 +6712,49 @@ LBB32_16: WORD $0xf8c5; BYTE $0x77 // vzeroupper BYTE $0xc3 // retq -LBB32_17: - LONG $0x03c28348 // addq $3, %rdx - LONG $0x08573b49 // cmpq $8(%r15), %rdx - LONG $0xffe0830f; WORD $0xffff // jae LBB32_16, $-32(%rip) - LONG $0x000801e9; BYTE $0x00 // jmp LBB32_81, $2049(%rip) +LBB27_45: + LONG $0x044b8d49 // leaq $4(%r11), %rcx + LONG $0x084f3b48 // cmpq $8(%rdi), %rcx + LONG $0xffe0870f; WORD $0xffff // ja LBB27_44, $-32(%rip) + LONG $0x00049ce9; BYTE $0x00 // jmp LBB27_82, $1180(%rip) -LBB32_18: - WORD $0x894d; BYTE $0x16 // movq %r10, (%r14) +LBB27_46: + WORD $0x894c; BYTE $0x1e // movq %r11, (%rsi) LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq $-2, %rax - LONG $0xffffcce9; BYTE $0xff // jmp LBB32_16, $-52(%rip) + LONG $0xffffcce9; BYTE $0xff // jmp LBB27_44, $-52(%rip) -LBB32_19: - WORD $0x894d; BYTE $0xd0 // movq %r10, %r8 - WORD $0x8b49; BYTE $0x0f // movq (%r15), %rcx - LONG $0x084f8b4d // movq $8(%r15), %r9 - LONG $0x244c8948; BYTE $0x08 // movq %rcx, $8(%rsp) - LONG $0x11148d4c // leaq (%rcx,%rdx), %r10 - WORD $0x2949; BYTE $0xd1 // subq %rdx, %r9 - LONG $0x20f98349 // cmpq $32, %r9 - LONG $0x07e9820f; WORD $0x0000 // jb LBB32_27, $2025(%rip) +LBB27_47: + LONG $0x08478b4c // movq $8(%rdi), %r8 + WORD $0x894d; BYTE $0xc7 // movq %r8, %r15 + WORD $0x2949; BYTE $0xdf // subq %rbx, %r15 + LONG $0x20ff8349 // cmpq $32, %r15 + LONG $0x08b18c0f; WORD $0x0000 // jl LBB27_116, $2225(%rip) + LONG $0xffffb941; WORD $0xffff // movl $4294967295, %r9d + LONG $0x1e148d4f // leaq (%r14,%r11), %r10 + WORD $0x294d; BYTE $0xd8 // subq %r11, %r8 + LONG $0x001fbd41; WORD $0x0000 // movl $31, %r13d WORD $0x3145; BYTE $0xff // xorl %r15d, %r15d - QUAD $0xfffffe25056ff9c5 // vmovdqa $-475(%rip), %xmm0 /* LCPI32_3(%rip) */ - QUAD $0xfffffe2d0d6ff9c5 // vmovdqa $-467(%rip), %xmm1 /* LCPI32_4(%rip) */ - WORD $0x3145; BYTE $0xed // xorl %r13d, %r13d - WORD $0x3145; BYTE $0xdb // xorl %r11d, %r11d - LONG $0x000028e9; BYTE $0x00 // jmp LBB32_21, $40(%rip) + QUAD $0xfffffcd2056ff9c5 // vmovdqa $-814(%rip), %xmm0 /* LCPI27_3(%rip) */ + QUAD $0xfffffcda0d6ff9c5 // vmovdqa $-806(%rip), %xmm1 /* LCPI27_4(%rip) */ + WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d + LONG $0x000024e9; BYTE $0x00 // jmp LBB27_49, $36(%rip) WORD $0x9090 // .p2align 4, 0x90 -LBB32_23: - WORD $0x3145; BYTE $0xdb // xorl %r11d, %r11d - WORD $0x8548; BYTE $0xc9 // testq %rcx, %rcx - LONG $0x009d850f; WORD $0x0000 // jne LBB32_79, $157(%rip) - -LBB32_24: - LONG $0x20c58349 // addq $32, %r13 - LONG $0x390c8d4b // leaq (%r9,%r15), %rcx - LONG $0xe0c18348 // addq $-32, %rcx - LONG $0xe0c78349 // addq $-32, %r15 - LONG $0x1ff98348 // cmpq $31, %rcx - LONG $0x0794860f; WORD $0x0000 // jbe LBB32_25, $1940(%rip) - -LBB32_21: - LONG $0x6f7a81c4; WORD $0x2a14 // vmovdqu (%r10,%r13), %xmm2 - LONG $0x6f7a81c4; WORD $0x2a5c; BYTE $0x10 // vmovdqu $16(%r10,%r13), %xmm3 +LBB27_51: + WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d + WORD $0xc985 // testl %ecx, %ecx + LONG $0x009e850f; WORD $0x0000 // jne LBB27_109, $158(%rip) + +LBB27_52: + LONG $0x20c78349 // addq $32, %r15 + LONG $0x284c8d4b; BYTE $0xe0 // leaq $-32(%r8,%r13), %rcx + LONG $0xe0c58349 // addq $-32, %r13 + LONG $0x3ff98348 // cmpq $63, %rcx + LONG $0x07dc8e0f; WORD $0x0000 // jle LBB27_53, $2012(%rip) + +LBB27_49: + LONG $0x6f7a81c4; WORD $0x3a54; BYTE $0x01 // vmovdqu $1(%r10,%r15), %xmm2 + LONG $0x6f7a81c4; WORD $0x3a5c; BYTE $0x11 // vmovdqu $17(%r10,%r15), %xmm3 LONG $0xe074e9c5 // vpcmpeqb %xmm0, %xmm2, %xmm4 LONG $0xfcd7f9c5 // vpmovmskb %xmm4, %edi LONG $0xe074e1c5 // vpcmpeqb %xmm0, %xmm3, %xmm4 @@ -7234,1155 +6762,2054 @@ LBB32_21: LONG $0x10e1c148 // shlq $16, %rcx WORD $0x0948; BYTE $0xf9 // orq %rdi, %rcx LONG $0xd174e9c5 // vpcmpeqb %xmm1, %xmm2, %xmm2 - LONG $0xf2d7f9c5 // vpmovmskb %xmm2, %esi + LONG $0xdad7f9c5 // vpmovmskb %xmm2, %ebx LONG $0xd174e1c5 // vpcmpeqb %xmm1, %xmm3, %xmm2 LONG $0xfad7f9c5 // vpmovmskb %xmm2, %edi LONG $0x10e7c148 // shlq $16, %rdi - WORD $0x0948; BYTE $0xf7 // orq %rsi, %rdi - WORD $0x8948; BYTE $0xfe // movq %rdi, %rsi - WORD $0x094c; BYTE $0xde // orq %r11, %rsi - LONG $0xff93840f; WORD $0xffff // je LBB32_23, $-109(%rip) - WORD $0x8944; BYTE $0xde // movl %r11d, %esi - WORD $0xd6f7 // notl %esi - WORD $0xfe21 // andl %edi, %esi - LONG $0x36248d44 // leal (%rsi,%rsi), %r12d - WORD $0x0945; BYTE $0xdc // orl %r11d, %r12d + WORD $0x0948; BYTE $0xdf // orq %rbx, %rdi + WORD $0x8948; BYTE $0xfb // movq %rdi, %rbx + WORD $0x094c; BYTE $0xe3 // orq %r12, %rbx + LONG $0xff96840f; WORD $0xffff // je LBB27_51, $-106(%rip) WORD $0x8944; BYTE $0xe3 // movl %r12d, %ebx - WORD $0xd3f7 // notl %ebx - WORD $0xfb21 // andl %edi, %ebx - LONG $0xaaaae381; WORD $0xaaaa // andl $-1431655766, %ebx - WORD $0x3145; BYTE $0xdb // xorl %r11d, %r11d - WORD $0xf301 // addl %esi, %ebx - LONG $0xc3920f41 // setb %r11b - WORD $0xdb01 // addl %ebx, %ebx - LONG $0x5555f381; WORD $0x5555 // xorl $1431655765, %ebx - WORD $0x2144; BYTE $0xe3 // andl %r12d, %ebx - WORD $0xd3f7 // notl %ebx - WORD $0xd921 // andl %ebx, %ecx - WORD $0x8548; BYTE $0xc9 // testq %rcx, %rcx - LONG $0xff63840f; WORD $0xffff // je LBB32_24, $-157(%rip) + WORD $0x3144; BYTE $0xcb // xorl %r9d, %ebx + WORD $0xdf21 // andl %ebx, %edi + WORD $0x1c8d; BYTE $0x3f // leal (%rdi,%rdi), %ebx + WORD $0x0944; BYTE $0xe3 // orl %r12d, %ebx + LONG $0xab918d41; WORD $0xaaaa; BYTE $0xaa // leal $-1431655765(%r9), %edx + WORD $0xda31 // xorl %ebx, %edx + WORD $0xfa21 // andl %edi, %edx + LONG $0xaaaae281; WORD $0xaaaa // andl $-1431655766, %edx + WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d + WORD $0xfa01 // addl %edi, %edx + LONG $0xc4920f41 // setb %r12b + WORD $0xd201 // addl %edx, %edx + LONG $0x5555f281; WORD $0x5555 // xorl $1431655765, %edx + WORD $0xda21 // andl %ebx, %edx + WORD $0x3144; BYTE $0xca // xorl %r9d, %edx + WORD $0xd121 // andl %edx, %ecx + WORD $0xc985 // testl %ecx, %ecx + LONG $0xff62840f; WORD $0xffff // je LBB27_52, $-158(%rip) -LBB32_79: - WORD $0xbc0f; BYTE $0xc1 // bsfl %ecx, %eax - WORD $0x0148; BYTE $0xd0 // addq %rdx, %rax - WORD $0x014c; BYTE $0xe8 // addq %r13, %rax - WORD $0xff48; BYTE $0xc0 // incq %rax - WORD $0x8949; BYTE $0x06 // movq %rax, (%r14) - WORD $0x894c; BYTE $0xc0 // movq %r8, %rax - LONG $0xfffecce9; BYTE $0xff // jmp LBB32_16, $-308(%rip) +LBB27_109: + LONG $0xc1bc0f48 // bsfq %rcx, %rax + WORD $0x0149; BYTE $0xc2 // addq %rax, %r10 + WORD $0x014d; BYTE $0xfa // addq %r15, %r10 + WORD $0x294d; BYTE $0xf2 // subq %r14, %r10 + LONG $0x02c28349 // addq $2, %r10 + WORD $0x894c; BYTE $0x16 // movq %r10, (%rsi) + LONG $0xfffec3e9; BYTE $0xff // jmp LBB27_43, $-317(%rip) -LBB32_28: - LONG $0x084f8b49 // movq $8(%r15), %rcx - WORD $0x2948; BYTE $0xd1 // subq %rdx, %rcx - WORD $0x0349; BYTE $0x17 // addq (%r15), %rdx - WORD $0x3145; BYTE $0xc9 // xorl %r9d, %r9d - QUAD $0xfffffd4b156f79c5 // vmovdqa $-693(%rip), %xmm10 /* LCPI32_4(%rip) */ - QUAD $0xfffffd330d6ff9c5 // vmovdqa $-717(%rip), %xmm1 /* LCPI32_3(%rip) */ +LBB27_56: + LONG $0x084f8b48 // movq $8(%rdi), %rcx + WORD $0x2948; BYTE $0xd9 // subq %rbx, %rcx + WORD $0x0149; BYTE $0xde // addq %rbx, %r14 + WORD $0x3145; BYTE $0xd2 // xorl %r10d, %r10d + QUAD $0xfffffbf9156f79c5 // vmovdqa $-1031(%rip), %xmm10 /* LCPI27_4(%rip) */ + QUAD $0xfffffbe10d6ff9c5 // vmovdqa $-1055(%rip), %xmm1 /* LCPI27_3(%rip) */ LONG $0x763141c4; BYTE $0xc9 // vpcmpeqd %xmm9, %xmm9, %xmm9 - QUAD $0xfffffd661d6ff9c5 // vmovdqa $-666(%rip), %xmm3 /* LCPI32_7(%rip) */ - QUAD $0xfffffd0e256ff9c5 // vmovdqa $-754(%rip), %xmm4 /* LCPI32_2(%rip) */ + QUAD $0xfffffc141d6ff9c5 // vmovdqa $-1004(%rip), %xmm3 /* LCPI27_7(%rip) */ + QUAD $0xfffffbbc256ff9c5 // vmovdqa $-1092(%rip), %xmm4 /* LCPI27_2(%rip) */ LONG $0x573841c4; BYTE $0xc0 // vxorps %xmm8, %xmm8, %xmm8 - WORD $0x3145; BYTE $0xdb // xorl %r11d, %r11d + WORD $0x3145; BYTE $0xff // xorl %r15d, %r15d WORD $0x3145; BYTE $0xc0 // xorl %r8d, %r8d - WORD $0xf631 // xorl %esi, %esi - LONG $0x2454894c; BYTE $0x18 // movq %r10, $24(%rsp) + WORD $0xdb31 // xorl %ebx, %ebx LONG $0x40f98348 // cmpq $64, %rcx LONG $0x244c8948; BYTE $0x08 // movq %rcx, $8(%rsp) - LONG $0x011f8d0f; WORD $0x0000 // jge LBB32_29, $287(%rip) + LONG $0x2444894c; BYTE $0x18 // movq %r8, $24(%rsp) + LONG $0x01338d0f; WORD $0x0000 // jge LBB27_57, $307(%rip) -LBB32_38: +LBB27_66: WORD $0x8548; BYTE $0xc9 // testq %rcx, %rcx - LONG $0x06cc8e0f; WORD $0x0000 // jle LBB32_83, $1740(%rip) + LONG $0x076b8e0f; WORD $0x0000 // jle LBB27_117, $1899(%rip) LONG $0x44297cc5; WORD $0x4024 // vmovaps %ymm8, $64(%rsp) LONG $0x44297cc5; WORD $0x2024 // vmovaps %ymm8, $32(%rsp) - WORD $0xd189 // movl %edx, %ecx + WORD $0x8944; BYTE $0xf1 // movl %r14d, %ecx LONG $0x0fffe181; WORD $0x0000 // andl $4095, %ecx LONG $0x0fc1f981; WORD $0x0000 // cmpl $4033, %ecx - LONG $0x00f6820f; WORD $0x0000 // jb LBB32_29, $246(%rip) + LONG $0x0109820f; WORD $0x0000 // jb LBB27_57, $265(%rip) LONG $0x247c8348; WORD $0x2008 // cmpq $32, $8(%rsp) - LONG $0x0021820f; WORD $0x0000 // jb LBB32_42, $33(%rip) - LONG $0x026ffec5 // vmovdqu (%rdx), %ymm0 - LONG $0x447ffdc5; WORD $0x2024 // vmovdqa %ymm0, $32(%rsp) - LONG $0x20c28348 // addq $32, %rdx + LONG $0x002e820f; WORD $0x0000 // jb LBB27_70, $46(%rip) + LONG $0x1078c1c4; BYTE $0x06 // vmovups (%r14), %xmm0 + LONG $0x4429f8c5; WORD $0x2024 // vmovaps %xmm0, $32(%rsp) + LONG $0x6f7ac1c4; WORD $0x1046 // vmovdqu $16(%r14), %xmm0 + LONG $0x447ff9c5; WORD $0x3024 // vmovdqa %xmm0, $48(%rsp) + LONG $0x20c68349 // addq $32, %r14 LONG $0x244c8b48; BYTE $0x08 // movq $8(%rsp), %rcx - LONG $0xe0798d48 // leaq $-32(%rcx), %rdi - LONG $0x245c8d48; BYTE $0x40 // leaq $64(%rsp), %rbx - LONG $0x00000ae9; BYTE $0x00 // jmp LBB32_43, $10(%rip) - -LBB32_42: - LONG $0x245c8d48; BYTE $0x20 // leaq $32(%rsp), %rbx - LONG $0x247c8b48; BYTE $0x08 // movq $8(%rsp), %rdi - -LBB32_43: - LONG $0x10ff8348 // cmpq $16, %rdi - LONG $0x0058820f; WORD $0x0000 // jb LBB32_44, $88(%rip) - LONG $0x026ffac5 // vmovdqu (%rdx), %xmm0 - LONG $0x037ffac5 // vmovdqu %xmm0, (%rbx) - LONG $0x10c28348 // addq $16, %rdx - LONG $0x10c38348 // addq $16, %rbx - LONG $0xf0c78348 // addq $-16, %rdi - LONG $0x08ff8348 // cmpq $8, %rdi - LONG $0x0044830f; WORD $0x0000 // jae LBB32_49, $68(%rip) - -LBB32_45: - LONG $0x04ff8348 // cmpq $4, %rdi - LONG $0x0056820f; WORD $0x0000 // jb LBB32_46, $86(%rip) - -LBB32_50: - WORD $0x0a8b // movl (%rdx), %ecx - WORD $0x0b89 // movl %ecx, (%rbx) - LONG $0x04c28348 // addq $4, %rdx - LONG $0x04c38348 // addq $4, %rbx - LONG $0xfcc78348 // addq $-4, %rdi - LONG $0x02ff8348 // cmpq $2, %rdi - LONG $0x0046830f; WORD $0x0000 // jae LBB32_51, $70(%rip) + LONG $0xe0518d48 // leaq $-32(%rcx), %rdx + LONG $0x24448d4c; BYTE $0x40 // leaq $64(%rsp), %r8 + LONG $0x00000ae9; BYTE $0x00 // jmp LBB27_71, $10(%rip) -LBB32_47: - WORD $0x8948; BYTE $0xd1 // movq %rdx, %rcx - LONG $0x24548d48; BYTE $0x20 // leaq $32(%rsp), %rdx - WORD $0x8548; BYTE $0xff // testq %rdi, %rdi - LONG $0x0058850f; WORD $0x0000 // jne LBB32_52, $88(%rip) - LONG $0x00005de9; BYTE $0x00 // jmp LBB32_29, $93(%rip) +LBB27_70: + LONG $0x24448d4c; BYTE $0x20 // leaq $32(%rsp), %r8 + LONG $0x24548b48; BYTE $0x08 // movq $8(%rsp), %rdx -LBB32_44: - LONG $0x08ff8348 // cmpq $8, %rdi - LONG $0xffbc820f; WORD $0xffff // jb LBB32_45, $-68(%rip) +LBB27_71: + LONG $0x10fa8348 // cmpq $16, %rdx + LONG $0x005c820f; WORD $0x0000 // jb LBB27_72, $92(%rip) + LONG $0x6f7ac1c4; BYTE $0x06 // vmovdqu (%r14), %xmm0 + LONG $0x7f7ac1c4; BYTE $0x00 // vmovdqu %xmm0, (%r8) + LONG $0x10c68349 // addq $16, %r14 + LONG $0x10c08349 // addq $16, %r8 + LONG $0xf0c28348 // addq $-16, %rdx + LONG $0x08fa8348 // cmpq $8, %rdx + LONG $0x0046830f; WORD $0x0000 // jae LBB27_77, $70(%rip) + +LBB27_73: + LONG $0x04fa8348 // cmpq $4, %rdx + LONG $0x00588c0f; WORD $0x0000 // jl LBB27_74, $88(%rip) + +LBB27_78: + WORD $0x8b41; BYTE $0x0e // movl (%r14), %ecx + WORD $0x8941; BYTE $0x08 // movl %ecx, (%r8) + LONG $0x04c68349 // addq $4, %r14 + LONG $0x04c08349 // addq $4, %r8 + LONG $0xfcc28348 // addq $-4, %rdx + LONG $0x02fa8348 // cmpq $2, %rdx + LONG $0x0046830f; WORD $0x0000 // jae LBB27_79, $70(%rip) -LBB32_49: - WORD $0x8b48; BYTE $0x0a // movq (%rdx), %rcx - WORD $0x8948; BYTE $0x0b // movq %rcx, (%rbx) - LONG $0x08c28348 // addq $8, %rdx - LONG $0x08c38348 // addq $8, %rbx - LONG $0xf8c78348 // addq $-8, %rdi - LONG $0x04ff8348 // cmpq $4, %rdi - LONG $0xffaa830f; WORD $0xffff // jae LBB32_50, $-86(%rip) - -LBB32_46: - LONG $0x02ff8348 // cmpq $2, %rdi - LONG $0xffba820f; WORD $0xffff // jb LBB32_47, $-70(%rip) - -LBB32_51: - WORD $0xb70f; BYTE $0x0a // movzwl (%rdx), %ecx - WORD $0x8966; BYTE $0x0b // movw %cx, (%rbx) - LONG $0x02c28348 // addq $2, %rdx - LONG $0x02c38348 // addq $2, %rbx - LONG $0xfec78348 // addq $-2, %rdi - WORD $0x8948; BYTE $0xd1 // movq %rdx, %rcx - LONG $0x24548d48; BYTE $0x20 // leaq $32(%rsp), %rdx - WORD $0x8548; BYTE $0xff // testq %rdi, %rdi - LONG $0x000a840f; WORD $0x0000 // je LBB32_29, $10(%rip) +LBB27_75: + WORD $0x894c; BYTE $0xf1 // movq %r14, %rcx + LONG $0x24748d4c; BYTE $0x20 // leaq $32(%rsp), %r14 + WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx + LONG $0x005a850f; WORD $0x0000 // jne LBB27_80, $90(%rip) + LONG $0x00005fe9; BYTE $0x00 // jmp LBB27_57, $95(%rip) -LBB32_52: - WORD $0xb60f; BYTE $0x09 // movzbl (%rcx), %ecx - WORD $0x0b88 // movb %cl, (%rbx) - LONG $0x24548d48; BYTE $0x20 // leaq $32(%rsp), %rdx - -LBB32_29: - LONG $0x126ffac5 // vmovdqu (%rdx), %xmm2 - LONG $0x6a6ffac5; BYTE $0x10 // vmovdqu $16(%rdx), %xmm5 - LONG $0x7a6ffac5; BYTE $0x20 // vmovdqu $32(%rdx), %xmm7 - LONG $0x726ffac5; BYTE $0x30 // vmovdqu $48(%rdx), %xmm6 - LONG $0xc274a9c5 // vpcmpeqb %xmm2, %xmm10, %xmm0 - LONG $0xe8d779c5 // vpmovmskb %xmm0, %r13d - LONG $0xc574a9c5 // vpcmpeqb %xmm5, %xmm10, %xmm0 - LONG $0xf8d7f9c5 // vpmovmskb %xmm0, %edi - LONG $0xc774a9c5 // vpcmpeqb %xmm7, %xmm10, %xmm0 - LONG $0xd8d7f9c5 // vpmovmskb %xmm0, %ebx - LONG $0xc674a9c5 // vpcmpeqb %xmm6, %xmm10, %xmm0 - LONG $0xc8d7f9c5 // vpmovmskb %xmm0, %ecx - LONG $0x30e1c148 // shlq $48, %rcx - LONG $0x20e3c148 // shlq $32, %rbx - WORD $0x0948; BYTE $0xcb // orq %rcx, %rbx - LONG $0x10e7c148 // shlq $16, %rdi - WORD $0x0948; BYTE $0xdf // orq %rbx, %rdi - WORD $0x0949; BYTE $0xfd // orq %rdi, %r13 - WORD $0x894c; BYTE $0xe9 // movq %r13, %rcx - WORD $0x094c; BYTE $0xd9 // orq %r11, %rcx - LONG $0x0013850f; WORD $0x0000 // jne LBB32_31, $19(%rip) - LONG $0xffc5c749; WORD $0xffff; BYTE $0xff // movq $-1, %r13 +LBB27_72: + LONG $0x08fa8348 // cmpq $8, %rdx + LONG $0xffba820f; WORD $0xffff // jb LBB27_73, $-70(%rip) + +LBB27_77: + WORD $0x8b49; BYTE $0x0e // movq (%r14), %rcx + WORD $0x8949; BYTE $0x08 // movq %rcx, (%r8) + LONG $0x08c68349 // addq $8, %r14 + LONG $0x08c08349 // addq $8, %r8 + LONG $0xf8c28348 // addq $-8, %rdx + LONG $0x04fa8348 // cmpq $4, %rdx + LONG $0xffa88d0f; WORD $0xffff // jge LBB27_78, $-88(%rip) + +LBB27_74: + LONG $0x02fa8348 // cmpq $2, %rdx + LONG $0xffba820f; WORD $0xffff // jb LBB27_75, $-70(%rip) + +LBB27_79: + LONG $0x0eb70f41 // movzwl (%r14), %ecx + LONG $0x08894166 // movw %cx, (%r8) + LONG $0x02c68349 // addq $2, %r14 + LONG $0x02c08349 // addq $2, %r8 + LONG $0xfec28348 // addq $-2, %rdx + WORD $0x894c; BYTE $0xf1 // movq %r14, %rcx + LONG $0x24748d4c; BYTE $0x20 // leaq $32(%rsp), %r14 + WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx + LONG $0x000a840f; WORD $0x0000 // je LBB27_57, $10(%rip) + +LBB27_80: + WORD $0x098a // movb (%rcx), %cl + WORD $0x8841; BYTE $0x08 // movb %cl, (%r8) + LONG $0x24748d4c; BYTE $0x20 // leaq $32(%rsp), %r14 + +LBB27_57: + LONG $0x6f7ac1c4; BYTE $0x16 // vmovdqu (%r14), %xmm2 + LONG $0x6f7ac1c4; WORD $0x106e // vmovdqu $16(%r14), %xmm5 + LONG $0x6f7ac1c4; WORD $0x207e // vmovdqu $32(%r14), %xmm7 + LONG $0x6f7ac1c4; WORD $0x3076 // vmovdqu $48(%r14), %xmm6 + LONG $0xc274a9c5 // vpcmpeqb %xmm2, %xmm10, %xmm0 + LONG $0xd0d7f9c5 // vpmovmskb %xmm0, %edx + LONG $0xc574a9c5 // vpcmpeqb %xmm5, %xmm10, %xmm0 + LONG $0xc8d7f9c5 // vpmovmskb %xmm0, %ecx + LONG $0xc774a9c5 // vpcmpeqb %xmm7, %xmm10, %xmm0 + LONG $0xe8d779c5 // vpmovmskb %xmm0, %r13d + LONG $0xc674a9c5 // vpcmpeqb %xmm6, %xmm10, %xmm0 + LONG $0xc8d779c5 // vpmovmskb %xmm0, %r9d + LONG $0x30e1c149 // shlq $48, %r9 + LONG $0x20e5c149 // shlq $32, %r13 + LONG $0x10e1c148 // shlq $16, %rcx + WORD $0x0948; BYTE $0xca // orq %rcx, %rdx + WORD $0x094c; BYTE $0xea // orq %r13, %rdx + WORD $0x094c; BYTE $0xca // orq %r9, %rdx + WORD $0x8948; BYTE $0xd1 // movq %rdx, %rcx + WORD $0x094c; BYTE $0xf9 // orq %r15, %rcx + LONG $0x004e840f; WORD $0x0000 // je LBB27_59, $78(%rip) + WORD $0x894d; BYTE $0xf8 // movq %r15, %r8 + WORD $0xf749; BYTE $0xd0 // notq %r8 + WORD $0x2149; BYTE $0xd0 // andq %rdx, %r8 + LONG $0x000c8d4f // leaq (%r8,%r8), %r9 + WORD $0x094d; BYTE $0xf9 // orq %r15, %r9 + WORD $0x894d; BYTE $0xcc // movq %r9, %r12 + QUAD $0xaaaaaaaaaaaab948; WORD $0xaaaa // movabsq $-6148914691236517206, %rcx + WORD $0x3149; BYTE $0xcc // xorq %rcx, %r12 + WORD $0x2148; BYTE $0xca // andq %rcx, %rdx + WORD $0x214c; BYTE $0xe2 // andq %r12, %rdx + WORD $0xc931 // xorl %ecx, %ecx + WORD $0x014c; BYTE $0xc2 // addq %r8, %rdx + WORD $0x920f; BYTE $0xc1 // setb %cl + LONG $0x244c8948; BYTE $0x10 // movq %rcx, $16(%rsp) + WORD $0x0148; BYTE $0xd2 // addq %rdx, %rdx + QUAD $0x555555555555b948; WORD $0x5555 // movabsq $6148914691236517205, %rcx + WORD $0x3148; BYTE $0xca // xorq %rcx, %rdx + WORD $0x214c; BYTE $0xca // andq %r9, %rdx + WORD $0xf748; BYTE $0xd2 // notq %rdx + LONG $0x00000ee9; BYTE $0x00 // jmp LBB27_60, $14(%rip) + +LBB27_59: + LONG $0xffc2c748; WORD $0xffff; BYTE $0xff // movq $-1, %rdx WORD $0xc931 // xorl %ecx, %ecx LONG $0x244c8948; BYTE $0x10 // movq %rcx, $16(%rsp) - LONG $0x00004ae9; BYTE $0x00 // jmp LBB32_32, $74(%rip) - -LBB32_31: - WORD $0x894c; BYTE $0xd9 // movq %r11, %rcx - WORD $0xf748; BYTE $0xd1 // notq %rcx - WORD $0x214c; BYTE $0xe9 // andq %r13, %rcx - LONG $0x09148d4c // leaq (%rcx,%rcx), %r10 - WORD $0x094d; BYTE $0xda // orq %r11, %r10 - WORD $0x894c; BYTE $0xd7 // movq %r10, %rdi - WORD $0xf748; BYTE $0xd7 // notq %rdi - QUAD $0xaaaaaaaaaaaabb48; WORD $0xaaaa // movabsq $-6148914691236517206, %rbx - WORD $0x2149; BYTE $0xdd // andq %rbx, %r13 - WORD $0x2149; BYTE $0xfd // andq %rdi, %r13 - WORD $0xff31 // xorl %edi, %edi - WORD $0x0149; BYTE $0xcd // addq %rcx, %r13 - LONG $0xc7920f40 // setb %dil - LONG $0x247c8948; BYTE $0x10 // movq %rdi, $16(%rsp) - WORD $0x014d; BYTE $0xed // addq %r13, %r13 - QUAD $0x555555555555b948; WORD $0x5555 // movabsq $6148914691236517205, %rcx - WORD $0x3149; BYTE $0xcd // xorq %rcx, %r13 - WORD $0x214d; BYTE $0xd5 // andq %r10, %r13 - WORD $0xf749; BYTE $0xd5 // notq %r13 -LBB32_32: - LONG $0xc174c9c5 // vpcmpeqb %xmm1, %xmm6, %xmm0 - LONG $0xc8d7f9c5 // vpmovmskb %xmm0, %ecx - LONG $0x30e1c148 // shlq $48, %rcx - LONG $0xc174c1c5 // vpcmpeqb %xmm1, %xmm7, %xmm0 - LONG $0xf8d7f9c5 // vpmovmskb %xmm0, %edi - LONG $0x20e7c148 // shlq $32, %rdi - WORD $0x0948; BYTE $0xcf // orq %rcx, %rdi +LBB27_60: LONG $0xc174d1c5 // vpcmpeqb %xmm1, %xmm5, %xmm0 LONG $0xc8d7f9c5 // vpmovmskb %xmm0, %ecx LONG $0x10e1c148 // shlq $16, %rcx - WORD $0x0948; BYTE $0xf9 // orq %rdi, %rcx LONG $0xc174e9c5 // vpcmpeqb %xmm1, %xmm2, %xmm0 - LONG $0xf8d7f9c5 // vpmovmskb %xmm0, %edi - WORD $0x0948; BYTE $0xcf // orq %rcx, %rdi - WORD $0x214c; BYTE $0xef // andq %r13, %rdi - LONG $0x6ef9e1c4; BYTE $0xc7 // vmovq %rdi, %xmm0 + LONG $0xc8d779c5 // vpmovmskb %xmm0, %r9d + WORD $0x0949; BYTE $0xc9 // orq %rcx, %r9 + LONG $0xc174c1c5 // vpcmpeqb %xmm1, %xmm7, %xmm0 + LONG $0xe8d779c5 // vpmovmskb %xmm0, %r13d + LONG $0x20e5c149 // shlq $32, %r13 + WORD $0x094d; BYTE $0xcd // orq %r9, %r13 + LONG $0xc174c9c5 // vpcmpeqb %xmm1, %xmm6, %xmm0 + LONG $0xc8d7f9c5 // vpmovmskb %xmm0, %ecx + LONG $0x30e1c148 // shlq $48, %rcx + WORD $0x094c; BYTE $0xe9 // orq %r13, %rcx + WORD $0x2148; BYTE $0xd1 // andq %rdx, %rcx + LONG $0x6ef9e1c4; BYTE $0xc1 // vmovq %rcx, %xmm0 LONG $0x4479c3c4; WORD $0x00c1 // vpclmulqdq $0, %xmm9, %xmm0, %xmm0 LONG $0x7ef9c1c4; BYTE $0xc5 // vmovq %xmm0, %r13 - WORD $0x314d; BYTE $0xcd // xorq %r9, %r13 + WORD $0x314d; BYTE $0xd5 // xorq %r10, %r13 LONG $0xc374e9c5 // vpcmpeqb %xmm3, %xmm2, %xmm0 - LONG $0xd0d779c5 // vpmovmskb %xmm0, %r10d + LONG $0xf8d779c5 // vpmovmskb %xmm0, %r15d LONG $0xc374d1c5 // vpcmpeqb %xmm3, %xmm5, %xmm0 - LONG $0xf8d7f9c5 // vpmovmskb %xmm0, %edi + LONG $0xc8d7f9c5 // vpmovmskb %xmm0, %ecx LONG $0xc374c1c5 // vpcmpeqb %xmm3, %xmm7, %xmm0 - LONG $0xd8d7f9c5 // vpmovmskb %xmm0, %ebx - LONG $0xc374c9c5 // vpcmpeqb %xmm3, %xmm6, %xmm0 LONG $0xc8d779c5 // vpmovmskb %xmm0, %r9d - LONG $0x30e1c149 // shlq $48, %r9 - LONG $0x20e3c148 // shlq $32, %rbx - WORD $0x094c; BYTE $0xcb // orq %r9, %rbx - LONG $0x10e7c148 // shlq $16, %rdi - WORD $0x0948; BYTE $0xdf // orq %rbx, %rdi - WORD $0x0949; BYTE $0xfa // orq %rdi, %r10 + LONG $0xc374c9c5 // vpcmpeqb %xmm3, %xmm6, %xmm0 + LONG $0xd0d779c5 // vpmovmskb %xmm0, %r10d + LONG $0x30e2c149 // shlq $48, %r10 + LONG $0x20e1c149 // shlq $32, %r9 + LONG $0x10e1c148 // shlq $16, %rcx + WORD $0x0949; BYTE $0xcf // orq %rcx, %r15 + WORD $0x094d; BYTE $0xcf // orq %r9, %r15 + WORD $0x094d; BYTE $0xd7 // orq %r10, %r15 WORD $0x894d; BYTE $0xe9 // movq %r13, %r9 WORD $0xf749; BYTE $0xd1 // notq %r9 - WORD $0x214d; BYTE $0xca // andq %r9, %r10 + WORD $0x214d; BYTE $0xcf // andq %r9, %r15 LONG $0xc474e9c5 // vpcmpeqb %xmm4, %xmm2, %xmm0 - LONG $0xf8d7f9c5 // vpmovmskb %xmm0, %edi + LONG $0xc8d7f9c5 // vpmovmskb %xmm0, %ecx LONG $0xc474d1c5 // vpcmpeqb %xmm4, %xmm5, %xmm0 - LONG $0xd8d7f9c5 // vpmovmskb %xmm0, %ebx + LONG $0xd0d779c5 // vpmovmskb %xmm0, %r10d LONG $0xc474c1c5 // vpcmpeqb %xmm4, %xmm7, %xmm0 - LONG $0xd8d779c5 // vpmovmskb %xmm0, %r11d + LONG $0xc0d779c5 // vpmovmskb %xmm0, %r8d LONG $0xc474c9c5 // vpcmpeqb %xmm4, %xmm6, %xmm0 LONG $0xe0d779c5 // vpmovmskb %xmm0, %r12d LONG $0x30e4c149 // shlq $48, %r12 - LONG $0x20e3c149 // shlq $32, %r11 - WORD $0x094d; BYTE $0xe3 // orq %r12, %r11 - LONG $0x10e3c148 // shlq $16, %rbx - WORD $0x094c; BYTE $0xdb // orq %r11, %rbx - WORD $0x0948; BYTE $0xdf // orq %rbx, %rdi - WORD $0x214c; BYTE $0xcf // andq %r9, %rdi - LONG $0x0032840f; WORD $0x0000 // je LBB32_36, $50(%rip) - LONG $0x245c8b4c; BYTE $0x10 // movq $16(%rsp), %r11 - BYTE $0x90 // .p2align 4, 0x90 + LONG $0x20e0c149 // shlq $32, %r8 + LONG $0x10e2c149 // shlq $16, %r10 + WORD $0x094c; BYTE $0xd1 // orq %r10, %rcx + WORD $0x094c; BYTE $0xc1 // orq %r8, %rcx + WORD $0x094c; BYTE $0xe1 // orq %r12, %rcx + WORD $0x214c; BYTE $0xc9 // andq %r9, %rcx + LONG $0x0039840f; WORD $0x0000 // je LBB27_64, $57(%rip) + LONG $0x24448b4c; BYTE $0x18 // movq $24(%rsp), %r8 + QUAD $0x9090909090909090 // .p2align 4, 0x90 -LBB32_34: - LONG $0xff4f8d48 // leaq $-1(%rdi), %rcx - WORD $0x8948; BYTE $0xcb // movq %rcx, %rbx - WORD $0x214c; BYTE $0xd3 // andq %r10, %rbx - LONG $0xb80f48f3; BYTE $0xdb // popcntq %rbx, %rbx - WORD $0x014c; BYTE $0xc3 // addq %r8, %rbx - WORD $0x3948; BYTE $0xf3 // cmpq %rsi, %rbx - LONG $0x03a5860f; WORD $0x0000 // jbe LBB32_78, $933(%rip) - WORD $0xff48; BYTE $0xc6 // incq %rsi - WORD $0x2148; BYTE $0xcf // andq %rcx, %rdi - LONG $0xffd9850f; WORD $0xffff // jne LBB32_34, $-39(%rip) - LONG $0x000005e9; BYTE $0x00 // jmp LBB32_37, $5(%rip) +LBB27_62: + LONG $0xff518d4c // leaq $-1(%rcx), %r10 + WORD $0x894c; BYTE $0xd2 // movq %r10, %rdx + WORD $0x214c; BYTE $0xfa // andq %r15, %rdx + LONG $0xb80f48f3; BYTE $0xd2 // popcntq %rdx, %rdx + WORD $0x014c; BYTE $0xc2 // addq %r8, %rdx + WORD $0x3948; BYTE $0xda // cmpq %rbx, %rdx + LONG $0x03e0860f; WORD $0x0000 // jbe LBB27_108, $992(%rip) + WORD $0xff48; BYTE $0xc3 // incq %rbx + WORD $0x214c; BYTE $0xd1 // andq %r10, %rcx + LONG $0xffd9850f; WORD $0xffff // jne LBB27_62, $-39(%rip) + LONG $0x000005e9; BYTE $0x00 // jmp LBB27_65, $5(%rip) -LBB32_36: - LONG $0x245c8b4c; BYTE $0x10 // movq $16(%rsp), %r11 +LBB27_64: + LONG $0x24448b4c; BYTE $0x18 // movq $24(%rsp), %r8 -LBB32_37: +LBB27_65: LONG $0x3ffdc149 // sarq $63, %r13 - LONG $0xb80f49f3; BYTE $0xca // popcntq %r10, %rcx + LONG $0xb80f49f3; BYTE $0xcf // popcntq %r15, %rcx WORD $0x0149; BYTE $0xc8 // addq %rcx, %r8 - LONG $0x40c28348 // addq $64, %rdx + LONG $0x40c68349 // addq $64, %r14 LONG $0x244c8b48; BYTE $0x08 // movq $8(%rsp), %rcx LONG $0xc0c18348 // addq $-64, %rcx - WORD $0x894d; BYTE $0xe9 // movq %r13, %r9 + WORD $0x894d; BYTE $0xea // movq %r13, %r10 + LONG $0x247c8b4c; BYTE $0x10 // movq $16(%rsp), %r15 LONG $0x40f98348 // cmpq $64, %rcx LONG $0x244c8948; BYTE $0x08 // movq %rcx, $8(%rsp) - LONG $0xfe268d0f; WORD $0xffff // jge LBB32_29, $-474(%rip) - LONG $0xfffd02e9; BYTE $0xff // jmp LBB32_38, $-766(%rip) - -LBB32_53: - LONG $0x04c28348 // addq $4, %rdx - LONG $0x08573b49 // cmpq $8(%r15), %rdx - LONG $0xfb6d830f; WORD $0xffff // jae LBB32_16, $-1171(%rip) - LONG $0x00038ee9; BYTE $0x00 // jmp LBB32_81, $910(%rip) - -LBB32_54: - LONG $0x084f8b49 // movq $8(%r15), %rcx - WORD $0x2948; BYTE $0xd1 // subq %rdx, %rcx - WORD $0x0349; BYTE $0x17 // addq (%r15), %rdx - WORD $0x3145; BYTE $0xc9 // xorl %r9d, %r9d - QUAD $0xfffff9e7156f79c5 // vmovdqa $-1561(%rip), %xmm10 /* LCPI32_4(%rip) */ - QUAD $0xfffff9cf0d6ff9c5 // vmovdqa $-1585(%rip), %xmm1 /* LCPI32_3(%rip) */ - LONG $0x763141c4; BYTE $0xc9 // vpcmpeqd %xmm9, %xmm9, %xmm9 - QUAD $0xfffff9e21d6ff9c5 // vmovdqa $-1566(%rip), %xmm3 /* LCPI32_5(%rip) */ - QUAD $0xfffff9ea256ff9c5 // vmovdqa $-1558(%rip), %xmm4 /* LCPI32_6(%rip) */ - LONG $0x573841c4; BYTE $0xc0 // vxorps %xmm8, %xmm8, %xmm8 - WORD $0x3145; BYTE $0xdb // xorl %r11d, %r11d - WORD $0x3145; BYTE $0xc0 // xorl %r8d, %r8d - WORD $0xf631 // xorl %esi, %esi - LONG $0x2454894c; BYTE $0x18 // movq %r10, $24(%rsp) - LONG $0x000021e9; BYTE $0x00 // jmp LBB32_56, $33(%rip) - -LBB32_55: - LONG $0x3ffdc149 // sarq $63, %r13 - LONG $0xb80f49f3; BYTE $0xca // popcntq %r10, %rcx - WORD $0x0149; BYTE $0xc8 // addq %rcx, %r8 - LONG $0x40c28348 // addq $64, %rdx - LONG $0x244c8b48; BYTE $0x08 // movq $8(%rsp), %rcx - LONG $0xc0c18348 // addq $-64, %rcx - WORD $0x894d; BYTE $0xe9 // movq %r13, %r9 - LONG $0x245c8b4c; BYTE $0x10 // movq $16(%rsp), %r11 - -LBB32_56: + LONG $0x2444894c; BYTE $0x18 // movq %r8, $24(%rsp) + LONG $0xfe128d0f; WORD $0xffff // jge LBB27_57, $-494(%rip) + LONG $0xfffcdae9; BYTE $0xff // jmp LBB27_66, $-806(%rip) + +LBB27_81: + LONG $0x054b8d49 // leaq $5(%r11), %rcx + LONG $0x084f3b48 // cmpq $8(%rdi), %rcx + LONG $0xfb3f870f; WORD $0xffff // ja LBB27_44, $-1217(%rip) + +LBB27_82: + WORD $0x8948; BYTE $0x0e // movq %rcx, (%rsi) + LONG $0xfffb34e9; BYTE $0xff // jmp LBB27_43, $-1228(%rip) + +LBB27_83: + LONG $0x084f8b48 // movq $8(%rdi), %rcx + WORD $0x2948; BYTE $0xd9 // subq %rbx, %rcx + WORD $0x0149; BYTE $0xde // addq %rbx, %r14 + WORD $0x3145; BYTE $0xd2 // xorl %r10d, %r10d + QUAD $0xfffff86a156f79c5 // vmovdqa $-1942(%rip), %xmm10 /* LCPI27_4(%rip) */ + QUAD $0xfffff8520d6ff9c5 // vmovdqa $-1966(%rip), %xmm1 /* LCPI27_3(%rip) */ + LONG $0x763141c4; BYTE $0xc9 // vpcmpeqd %xmm9, %xmm9, %xmm9 + QUAD $0xfffff8651d6ff9c5 // vmovdqa $-1947(%rip), %xmm3 /* LCPI27_5(%rip) */ + QUAD $0xfffff86d256ff9c5 // vmovdqa $-1939(%rip), %xmm4 /* LCPI27_6(%rip) */ + LONG $0x573841c4; BYTE $0xc0 // vxorps %xmm8, %xmm8, %xmm8 + WORD $0x3145; BYTE $0xff // xorl %r15d, %r15d + WORD $0x3145; BYTE $0xc0 // xorl %r8d, %r8d + WORD $0xdb31 // xorl %ebx, %ebx LONG $0x40f98348 // cmpq $64, %rcx LONG $0x244c8948; BYTE $0x08 // movq %rcx, $8(%rsp) - LONG $0x01af8c0f; WORD $0x0000 // jl LBB32_63, $431(%rip) - -LBB32_57: - LONG $0x126ffac5 // vmovdqu (%rdx), %xmm2 - LONG $0x6a6ffac5; BYTE $0x10 // vmovdqu $16(%rdx), %xmm5 - LONG $0x7a6ffac5; BYTE $0x20 // vmovdqu $32(%rdx), %xmm7 - LONG $0x726ffac5; BYTE $0x30 // vmovdqu $48(%rdx), %xmm6 - LONG $0xc274a9c5 // vpcmpeqb %xmm2, %xmm10, %xmm0 - LONG $0xe0d779c5 // vpmovmskb %xmm0, %r12d - LONG $0xc574a9c5 // vpcmpeqb %xmm5, %xmm10, %xmm0 - LONG $0xf8d7f9c5 // vpmovmskb %xmm0, %edi - LONG $0xc774a9c5 // vpcmpeqb %xmm7, %xmm10, %xmm0 - LONG $0xd8d7f9c5 // vpmovmskb %xmm0, %ebx - LONG $0xc674a9c5 // vpcmpeqb %xmm6, %xmm10, %xmm0 - LONG $0xc8d7f9c5 // vpmovmskb %xmm0, %ecx - LONG $0x30e1c148 // shlq $48, %rcx - LONG $0x20e3c148 // shlq $32, %rbx - WORD $0x0948; BYTE $0xcb // orq %rcx, %rbx - LONG $0x10e7c148 // shlq $16, %rdi - WORD $0x0948; BYTE $0xdf // orq %rbx, %rdi - WORD $0x0949; BYTE $0xfc // orq %rdi, %r12 - WORD $0x894c; BYTE $0xe1 // movq %r12, %rcx - WORD $0x094c; BYTE $0xd9 // orq %r11, %rcx - LONG $0x0013850f; WORD $0x0000 // jne LBB32_59, $19(%rip) - LONG $0xffc4c749; WORD $0xffff; BYTE $0xff // movq $-1, %r12 - WORD $0xc931 // xorl %ecx, %ecx - LONG $0x244c8948; BYTE $0x10 // movq %rcx, $16(%rsp) - LONG $0x00004ae9; BYTE $0x00 // jmp LBB32_60, $74(%rip) - -LBB32_59: - WORD $0x894c; BYTE $0xd9 // movq %r11, %rcx - WORD $0xf748; BYTE $0xd1 // notq %rcx - WORD $0x214c; BYTE $0xe1 // andq %r12, %rcx - LONG $0x09148d4c // leaq (%rcx,%rcx), %r10 - WORD $0x094d; BYTE $0xda // orq %r11, %r10 - WORD $0x894c; BYTE $0xd7 // movq %r10, %rdi - WORD $0xf748; BYTE $0xd7 // notq %rdi - QUAD $0xaaaaaaaaaaaabb48; WORD $0xaaaa // movabsq $-6148914691236517206, %rbx - WORD $0x2149; BYTE $0xdc // andq %rbx, %r12 - WORD $0x2149; BYTE $0xfc // andq %rdi, %r12 - WORD $0xff31 // xorl %edi, %edi - WORD $0x0149; BYTE $0xcc // addq %rcx, %r12 - LONG $0xc7920f40 // setb %dil - LONG $0x247c8948; BYTE $0x10 // movq %rdi, $16(%rsp) - WORD $0x014d; BYTE $0xe4 // addq %r12, %r12 - QUAD $0x555555555555b948; WORD $0x5555 // movabsq $6148914691236517205, %rcx - WORD $0x3149; BYTE $0xcc // xorq %rcx, %r12 - WORD $0x214d; BYTE $0xd4 // andq %r10, %r12 - WORD $0xf749; BYTE $0xd4 // notq %r12 - -LBB32_60: - LONG $0xc174c9c5 // vpcmpeqb %xmm1, %xmm6, %xmm0 - LONG $0xc8d7f9c5 // vpmovmskb %xmm0, %ecx - LONG $0x30e1c148 // shlq $48, %rcx - LONG $0xc174c1c5 // vpcmpeqb %xmm1, %xmm7, %xmm0 - LONG $0xf8d7f9c5 // vpmovmskb %xmm0, %edi - LONG $0x20e7c148 // shlq $32, %rdi - WORD $0x0948; BYTE $0xcf // orq %rcx, %rdi - LONG $0xc174d1c5 // vpcmpeqb %xmm1, %xmm5, %xmm0 - LONG $0xc8d7f9c5 // vpmovmskb %xmm0, %ecx - LONG $0x10e1c148 // shlq $16, %rcx - WORD $0x0948; BYTE $0xf9 // orq %rdi, %rcx - LONG $0xc174e9c5 // vpcmpeqb %xmm1, %xmm2, %xmm0 - LONG $0xf8d7f9c5 // vpmovmskb %xmm0, %edi - WORD $0x0948; BYTE $0xcf // orq %rcx, %rdi - WORD $0x214c; BYTE $0xe7 // andq %r12, %rdi - LONG $0x6ef9e1c4; BYTE $0xc7 // vmovq %rdi, %xmm0 - LONG $0x4479c3c4; WORD $0x00c1 // vpclmulqdq $0, %xmm9, %xmm0, %xmm0 - LONG $0x7ef9c1c4; BYTE $0xc5 // vmovq %xmm0, %r13 - WORD $0x314d; BYTE $0xcd // xorq %r9, %r13 - LONG $0xc374e9c5 // vpcmpeqb %xmm3, %xmm2, %xmm0 - LONG $0xd0d779c5 // vpmovmskb %xmm0, %r10d - LONG $0xc374d1c5 // vpcmpeqb %xmm3, %xmm5, %xmm0 - LONG $0xf8d7f9c5 // vpmovmskb %xmm0, %edi - LONG $0xc374c1c5 // vpcmpeqb %xmm3, %xmm7, %xmm0 - LONG $0xd8d7f9c5 // vpmovmskb %xmm0, %ebx - LONG $0xc374c9c5 // vpcmpeqb %xmm3, %xmm6, %xmm0 - LONG $0xc8d779c5 // vpmovmskb %xmm0, %r9d - LONG $0x30e1c149 // shlq $48, %r9 - LONG $0x20e3c148 // shlq $32, %rbx - WORD $0x094c; BYTE $0xcb // orq %r9, %rbx - LONG $0x10e7c148 // shlq $16, %rdi - WORD $0x0948; BYTE $0xdf // orq %rbx, %rdi - WORD $0x0949; BYTE $0xfa // orq %rdi, %r10 - WORD $0x894d; BYTE $0xe9 // movq %r13, %r9 - WORD $0xf749; BYTE $0xd1 // notq %r9 - WORD $0x214d; BYTE $0xca // andq %r9, %r10 - LONG $0xc474e9c5 // vpcmpeqb %xmm4, %xmm2, %xmm0 - LONG $0xf8d7f9c5 // vpmovmskb %xmm0, %edi - LONG $0xc474d1c5 // vpcmpeqb %xmm4, %xmm5, %xmm0 - LONG $0xe0d779c5 // vpmovmskb %xmm0, %r12d - LONG $0xc474c1c5 // vpcmpeqb %xmm4, %xmm7, %xmm0 - LONG $0xd8d7f9c5 // vpmovmskb %xmm0, %ebx - LONG $0xc474c9c5 // vpcmpeqb %xmm4, %xmm6, %xmm0 - LONG $0xd8d779c5 // vpmovmskb %xmm0, %r11d - LONG $0x30e3c149 // shlq $48, %r11 - LONG $0x20e3c148 // shlq $32, %rbx - WORD $0x094c; BYTE $0xdb // orq %r11, %rbx - LONG $0x10e4c149 // shlq $16, %r12 - WORD $0x0949; BYTE $0xdc // orq %rbx, %r12 - WORD $0x094c; BYTE $0xe7 // orq %r12, %rdi - WORD $0x214c; BYTE $0xcf // andq %r9, %rdi - LONG $0xfe58840f; WORD $0xffff // je LBB32_55, $-424(%rip) - QUAD $0x9090909090909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + LONG $0x2444894c; BYTE $0x18 // movq %r8, $24(%rsp) + LONG $0x01338d0f; WORD $0x0000 // jge LBB27_84, $307(%rip) -LBB32_61: - LONG $0xff4f8d48 // leaq $-1(%rdi), %rcx - WORD $0x8948; BYTE $0xcb // movq %rcx, %rbx - WORD $0x214c; BYTE $0xd3 // andq %r10, %rbx - LONG $0xb80f48f3; BYTE $0xdb // popcntq %rbx, %rbx - WORD $0x014c; BYTE $0xc3 // addq %r8, %rbx - WORD $0x3948; BYTE $0xf3 // cmpq %rsi, %rbx - LONG $0x0135860f; WORD $0x0000 // jbe LBB32_78, $309(%rip) - WORD $0xff48; BYTE $0xc6 // incq %rsi - WORD $0x2148; BYTE $0xcf // andq %rcx, %rdi - LONG $0xffd9850f; WORD $0xffff // jne LBB32_61, $-39(%rip) - LONG $0xfffe21e9; BYTE $0xff // jmp LBB32_55, $-479(%rip) - -LBB32_63: +LBB27_93: WORD $0x8548; BYTE $0xc9 // testq %rcx, %rcx - LONG $0x01938e0f; WORD $0x0000 // jle LBB32_83, $403(%rip) + LONG $0x03dc8e0f; WORD $0x0000 // jle LBB27_117, $988(%rip) LONG $0x44297cc5; WORD $0x4024 // vmovaps %ymm8, $64(%rsp) LONG $0x44297cc5; WORD $0x2024 // vmovaps %ymm8, $32(%rsp) - WORD $0xd189 // movl %edx, %ecx + WORD $0x8944; BYTE $0xf1 // movl %r14d, %ecx LONG $0x0fffe181; WORD $0x0000 // andl $4095, %ecx LONG $0x0fc1f981; WORD $0x0000 // cmpl $4033, %ecx - LONG $0xfe28820f; WORD $0xffff // jb LBB32_57, $-472(%rip) + LONG $0x0109820f; WORD $0x0000 // jb LBB27_84, $265(%rip) LONG $0x247c8348; WORD $0x2008 // cmpq $32, $8(%rsp) - LONG $0x0021820f; WORD $0x0000 // jb LBB32_67, $33(%rip) - LONG $0x0210fcc5 // vmovups (%rdx), %ymm0 - LONG $0x4429fcc5; WORD $0x2024 // vmovaps %ymm0, $32(%rsp) - LONG $0x20c28348 // addq $32, %rdx + LONG $0x002e820f; WORD $0x0000 // jb LBB27_97, $46(%rip) + LONG $0x1078c1c4; BYTE $0x06 // vmovups (%r14), %xmm0 + LONG $0x4429f8c5; WORD $0x2024 // vmovaps %xmm0, $32(%rsp) + LONG $0x6f7ac1c4; WORD $0x1046 // vmovdqu $16(%r14), %xmm0 + LONG $0x447ff9c5; WORD $0x3024 // vmovdqa %xmm0, $48(%rsp) + LONG $0x20c68349 // addq $32, %r14 LONG $0x244c8b48; BYTE $0x08 // movq $8(%rsp), %rcx - LONG $0xe0798d48 // leaq $-32(%rcx), %rdi - LONG $0x245c8d48; BYTE $0x40 // leaq $64(%rsp), %rbx - LONG $0x00000ae9; BYTE $0x00 // jmp LBB32_68, $10(%rip) - -LBB32_67: - LONG $0x245c8d48; BYTE $0x20 // leaq $32(%rsp), %rbx - LONG $0x247c8b48; BYTE $0x08 // movq $8(%rsp), %rdi - -LBB32_68: - LONG $0x10ff8348 // cmpq $16, %rdi - LONG $0x0058820f; WORD $0x0000 // jb LBB32_69, $88(%rip) - LONG $0x0210f8c5 // vmovups (%rdx), %xmm0 - LONG $0x0311f8c5 // vmovups %xmm0, (%rbx) - LONG $0x10c28348 // addq $16, %rdx - LONG $0x10c38348 // addq $16, %rbx - LONG $0xf0c78348 // addq $-16, %rdi - LONG $0x08ff8348 // cmpq $8, %rdi - LONG $0x0044830f; WORD $0x0000 // jae LBB32_74, $68(%rip) - -LBB32_70: - LONG $0x04ff8348 // cmpq $4, %rdi - LONG $0x0056820f; WORD $0x0000 // jb LBB32_71, $86(%rip) - -LBB32_75: - WORD $0x0a8b // movl (%rdx), %ecx - WORD $0x0b89 // movl %ecx, (%rbx) - LONG $0x04c28348 // addq $4, %rdx - LONG $0x04c38348 // addq $4, %rbx - LONG $0xfcc78348 // addq $-4, %rdi - LONG $0x02ff8348 // cmpq $2, %rdi - LONG $0x0046830f; WORD $0x0000 // jae LBB32_76, $70(%rip) + LONG $0xe0518d48 // leaq $-32(%rcx), %rdx + LONG $0x24448d4c; BYTE $0x40 // leaq $64(%rsp), %r8 + LONG $0x00000ae9; BYTE $0x00 // jmp LBB27_98, $10(%rip) -LBB32_72: - WORD $0x8948; BYTE $0xd1 // movq %rdx, %rcx - LONG $0x24548d48; BYTE $0x20 // leaq $32(%rsp), %rdx - WORD $0x8548; BYTE $0xff // testq %rdi, %rdi - LONG $0x0058850f; WORD $0x0000 // jne LBB32_77, $88(%rip) - LONG $0xfffd8fe9; BYTE $0xff // jmp LBB32_57, $-625(%rip) +LBB27_97: + LONG $0x24448d4c; BYTE $0x20 // leaq $32(%rsp), %r8 + LONG $0x24548b48; BYTE $0x08 // movq $8(%rsp), %rdx -LBB32_69: - LONG $0x08ff8348 // cmpq $8, %rdi - LONG $0xffbc820f; WORD $0xffff // jb LBB32_70, $-68(%rip) +LBB27_98: + LONG $0x10fa8348 // cmpq $16, %rdx + LONG $0x005c820f; WORD $0x0000 // jb LBB27_99, $92(%rip) + LONG $0x6f7ac1c4; BYTE $0x06 // vmovdqu (%r14), %xmm0 + LONG $0x7f7ac1c4; BYTE $0x00 // vmovdqu %xmm0, (%r8) + LONG $0x10c68349 // addq $16, %r14 + LONG $0x10c08349 // addq $16, %r8 + LONG $0xf0c28348 // addq $-16, %rdx + LONG $0x08fa8348 // cmpq $8, %rdx + LONG $0x0046830f; WORD $0x0000 // jae LBB27_104, $70(%rip) + +LBB27_100: + LONG $0x04fa8348 // cmpq $4, %rdx + LONG $0x00588c0f; WORD $0x0000 // jl LBB27_101, $88(%rip) + +LBB27_105: + WORD $0x8b41; BYTE $0x0e // movl (%r14), %ecx + WORD $0x8941; BYTE $0x08 // movl %ecx, (%r8) + LONG $0x04c68349 // addq $4, %r14 + LONG $0x04c08349 // addq $4, %r8 + LONG $0xfcc28348 // addq $-4, %rdx + LONG $0x02fa8348 // cmpq $2, %rdx + LONG $0x0046830f; WORD $0x0000 // jae LBB27_106, $70(%rip) -LBB32_74: - WORD $0x8b48; BYTE $0x0a // movq (%rdx), %rcx - WORD $0x8948; BYTE $0x0b // movq %rcx, (%rbx) - LONG $0x08c28348 // addq $8, %rdx - LONG $0x08c38348 // addq $8, %rbx - LONG $0xf8c78348 // addq $-8, %rdi - LONG $0x04ff8348 // cmpq $4, %rdi - LONG $0xffaa830f; WORD $0xffff // jae LBB32_75, $-86(%rip) - -LBB32_71: - LONG $0x02ff8348 // cmpq $2, %rdi - LONG $0xffba820f; WORD $0xffff // jb LBB32_72, $-70(%rip) - -LBB32_76: - WORD $0xb70f; BYTE $0x0a // movzwl (%rdx), %ecx - WORD $0x8966; BYTE $0x0b // movw %cx, (%rbx) - LONG $0x02c28348 // addq $2, %rdx - LONG $0x02c38348 // addq $2, %rbx - LONG $0xfec78348 // addq $-2, %rdi - WORD $0x8948; BYTE $0xd1 // movq %rdx, %rcx - LONG $0x24548d48; BYTE $0x20 // leaq $32(%rsp), %rdx - WORD $0x8548; BYTE $0xff // testq %rdi, %rdi - LONG $0xfd3c840f; WORD $0xffff // je LBB32_57, $-708(%rip) +LBB27_102: + WORD $0x894c; BYTE $0xf1 // movq %r14, %rcx + LONG $0x24748d4c; BYTE $0x20 // leaq $32(%rsp), %r14 + WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx + LONG $0x005a850f; WORD $0x0000 // jne LBB27_107, $90(%rip) + LONG $0x00005fe9; BYTE $0x00 // jmp LBB27_84, $95(%rip) -LBB32_77: - WORD $0xb60f; BYTE $0x09 // movzbl (%rcx), %ecx - WORD $0x0b88 // movb %cl, (%rbx) - LONG $0x24548d48; BYTE $0x20 // leaq $32(%rsp), %rdx - LONG $0xfffd2de9; BYTE $0xff // jmp LBB32_57, $-723(%rip) +LBB27_99: + LONG $0x08fa8348 // cmpq $8, %rdx + LONG $0xffba820f; WORD $0xffff // jb LBB27_100, $-70(%rip) -LBB32_78: - LONG $0x08478b49 // movq $8(%r15), %rax - LONG $0xcfbc0f48 // bsfq %rdi, %rcx - LONG $0x244c2b48; BYTE $0x08 // subq $8(%rsp), %rcx - WORD $0x0148; BYTE $0xc8 // addq %rcx, %rax - WORD $0xff48; BYTE $0xc0 // incq %rax - WORD $0x8949; BYTE $0x06 // movq %rax, (%r14) - LONG $0x084f8b49 // movq $8(%r15), %rcx - WORD $0x3948; BYTE $0xc8 // cmpq %rcx, %rax - LONG $0xc8420f48 // cmovbq %rax, %rcx - WORD $0x8949; BYTE $0x0e // movq %rcx, (%r14) - LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax - LONG $0x244c8b48; BYTE $0x18 // movq $24(%rsp), %rcx - LONG $0xc8470f48 // cmovaq %rax, %rcx - WORD $0x8948; BYTE $0xc8 // movq %rcx, %rax - LONG $0xfff7e0e9; BYTE $0xff // jmp LBB32_16, $-2080(%rip) +LBB27_104: + WORD $0x8b49; BYTE $0x0e // movq (%r14), %rcx + WORD $0x8949; BYTE $0x08 // movq %rcx, (%r8) + LONG $0x08c68349 // addq $8, %r14 + LONG $0x08c08349 // addq $8, %r8 + LONG $0xf8c28348 // addq $-8, %rdx + LONG $0x04fa8348 // cmpq $4, %rdx + LONG $0xffa88d0f; WORD $0xffff // jge LBB27_105, $-88(%rip) -LBB32_80: - WORD $0x2948; BYTE $0xc2 // subq %rax, %rdx - WORD $0x0148; BYTE $0xf2 // addq %rsi, %rdx +LBB27_101: + LONG $0x02fa8348 // cmpq $2, %rdx + LONG $0xffba820f; WORD $0xffff // jb LBB27_102, $-70(%rip) -LBB32_81: - WORD $0x8949; BYTE $0x16 // movq %rdx, (%r14) - LONG $0xfff7cfe9; BYTE $0xff // jmp LBB32_15, $-2097(%rip) +LBB27_106: + LONG $0x0eb70f41 // movzwl (%r14), %ecx + LONG $0x08894166 // movw %cx, (%r8) + LONG $0x02c68349 // addq $2, %r14 + LONG $0x02c08349 // addq $2, %r8 + LONG $0xfec28348 // addq $-2, %rdx + WORD $0x894c; BYTE $0xf1 // movq %r14, %rcx + LONG $0x24748d4c; BYTE $0x20 // leaq $32(%rsp), %r14 + WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx + LONG $0x000a840f; WORD $0x0000 // je LBB27_84, $10(%rip) + +LBB27_107: + WORD $0x098a // movb (%rcx), %cl + WORD $0x8841; BYTE $0x08 // movb %cl, (%r8) + LONG $0x24748d4c; BYTE $0x20 // leaq $32(%rsp), %r14 + +LBB27_84: + LONG $0x6f7ac1c4; BYTE $0x16 // vmovdqu (%r14), %xmm2 + LONG $0x6f7ac1c4; WORD $0x106e // vmovdqu $16(%r14), %xmm5 + LONG $0x6f7ac1c4; WORD $0x207e // vmovdqu $32(%r14), %xmm7 + LONG $0x6f7ac1c4; WORD $0x3076 // vmovdqu $48(%r14), %xmm6 + LONG $0xc274a9c5 // vpcmpeqb %xmm2, %xmm10, %xmm0 + LONG $0xd0d7f9c5 // vpmovmskb %xmm0, %edx + LONG $0xc574a9c5 // vpcmpeqb %xmm5, %xmm10, %xmm0 + LONG $0xc8d7f9c5 // vpmovmskb %xmm0, %ecx + LONG $0xc774a9c5 // vpcmpeqb %xmm7, %xmm10, %xmm0 + LONG $0xe8d779c5 // vpmovmskb %xmm0, %r13d + LONG $0xc674a9c5 // vpcmpeqb %xmm6, %xmm10, %xmm0 + LONG $0xc8d779c5 // vpmovmskb %xmm0, %r9d + LONG $0x30e1c149 // shlq $48, %r9 + LONG $0x20e5c149 // shlq $32, %r13 + LONG $0x10e1c148 // shlq $16, %rcx + WORD $0x0948; BYTE $0xca // orq %rcx, %rdx + WORD $0x094c; BYTE $0xea // orq %r13, %rdx + WORD $0x094c; BYTE $0xca // orq %r9, %rdx + WORD $0x8948; BYTE $0xd1 // movq %rdx, %rcx + WORD $0x094c; BYTE $0xf9 // orq %r15, %rcx + LONG $0x004e840f; WORD $0x0000 // je LBB27_86, $78(%rip) + WORD $0x894d; BYTE $0xf8 // movq %r15, %r8 + WORD $0xf749; BYTE $0xd0 // notq %r8 + WORD $0x2149; BYTE $0xd0 // andq %rdx, %r8 + LONG $0x000c8d4f // leaq (%r8,%r8), %r9 + WORD $0x094d; BYTE $0xf9 // orq %r15, %r9 + WORD $0x894d; BYTE $0xcc // movq %r9, %r12 + QUAD $0xaaaaaaaaaaaab948; WORD $0xaaaa // movabsq $-6148914691236517206, %rcx + WORD $0x3149; BYTE $0xcc // xorq %rcx, %r12 + WORD $0x2148; BYTE $0xca // andq %rcx, %rdx + WORD $0x214c; BYTE $0xe2 // andq %r12, %rdx + WORD $0xc931 // xorl %ecx, %ecx + WORD $0x014c; BYTE $0xc2 // addq %r8, %rdx + WORD $0x920f; BYTE $0xc1 // setb %cl + LONG $0x244c8948; BYTE $0x10 // movq %rcx, $16(%rsp) + WORD $0x0148; BYTE $0xd2 // addq %rdx, %rdx + QUAD $0x555555555555b948; WORD $0x5555 // movabsq $6148914691236517205, %rcx + WORD $0x3148; BYTE $0xca // xorq %rcx, %rdx + WORD $0x214c; BYTE $0xca // andq %r9, %rdx + WORD $0xf748; BYTE $0xd2 // notq %rdx + LONG $0x00000ee9; BYTE $0x00 // jmp LBB27_87, $14(%rip) -LBB32_25: - WORD $0x854d; BYTE $0xdb // testq %r11, %r11 - LONG $0x0031850f; WORD $0x0000 // jne LBB32_84, $49(%rip) - WORD $0x014d; BYTE $0xea // addq %r13, %r10 - WORD $0x014d; BYTE $0xf9 // addq %r15, %r9 +LBB27_86: + LONG $0xffc2c748; WORD $0xffff; BYTE $0xff // movq $-1, %rdx + WORD $0xc931 // xorl %ecx, %ecx + LONG $0x244c8948; BYTE $0x10 // movq %rcx, $16(%rsp) -LBB32_27: - WORD $0x854d; BYTE $0xc9 // testq %r9, %r9 - LONG $0x0064850f; WORD $0x0000 // jne LBB32_88, $100(%rip) - LONG $0xfff7b5e9; BYTE $0xff // jmp LBB32_16, $-2123(%rip) +LBB27_87: + LONG $0xc174d1c5 // vpcmpeqb %xmm1, %xmm5, %xmm0 + LONG $0xc8d7f9c5 // vpmovmskb %xmm0, %ecx + LONG $0x10e1c148 // shlq $16, %rcx + LONG $0xc174e9c5 // vpcmpeqb %xmm1, %xmm2, %xmm0 + LONG $0xc8d779c5 // vpmovmskb %xmm0, %r9d + WORD $0x0949; BYTE $0xc9 // orq %rcx, %r9 + LONG $0xc174c1c5 // vpcmpeqb %xmm1, %xmm7, %xmm0 + LONG $0xe8d779c5 // vpmovmskb %xmm0, %r13d + LONG $0x20e5c149 // shlq $32, %r13 + WORD $0x094d; BYTE $0xcd // orq %r9, %r13 + LONG $0xc174c9c5 // vpcmpeqb %xmm1, %xmm6, %xmm0 + LONG $0xc8d7f9c5 // vpmovmskb %xmm0, %ecx + LONG $0x30e1c148 // shlq $48, %rcx + WORD $0x094c; BYTE $0xe9 // orq %r13, %rcx + WORD $0x2148; BYTE $0xd1 // andq %rdx, %rcx + LONG $0x6ef9e1c4; BYTE $0xc1 // vmovq %rcx, %xmm0 + LONG $0x4479c3c4; WORD $0x00c1 // vpclmulqdq $0, %xmm9, %xmm0, %xmm0 + LONG $0x7ef9c1c4; BYTE $0xc5 // vmovq %xmm0, %r13 + WORD $0x314d; BYTE $0xd5 // xorq %r10, %r13 + LONG $0xc374e9c5 // vpcmpeqb %xmm3, %xmm2, %xmm0 + LONG $0xf8d779c5 // vpmovmskb %xmm0, %r15d + LONG $0xc374d1c5 // vpcmpeqb %xmm3, %xmm5, %xmm0 + LONG $0xc8d7f9c5 // vpmovmskb %xmm0, %ecx + LONG $0xc374c1c5 // vpcmpeqb %xmm3, %xmm7, %xmm0 + LONG $0xc8d779c5 // vpmovmskb %xmm0, %r9d + LONG $0xc374c9c5 // vpcmpeqb %xmm3, %xmm6, %xmm0 + LONG $0xd0d779c5 // vpmovmskb %xmm0, %r10d + LONG $0x30e2c149 // shlq $48, %r10 + LONG $0x20e1c149 // shlq $32, %r9 + LONG $0x10e1c148 // shlq $16, %rcx + WORD $0x0949; BYTE $0xcf // orq %rcx, %r15 + WORD $0x094d; BYTE $0xcf // orq %r9, %r15 + WORD $0x094d; BYTE $0xd7 // orq %r10, %r15 + WORD $0x894d; BYTE $0xe9 // movq %r13, %r9 + WORD $0xf749; BYTE $0xd1 // notq %r9 + WORD $0x214d; BYTE $0xcf // andq %r9, %r15 + LONG $0xc474e9c5 // vpcmpeqb %xmm4, %xmm2, %xmm0 + LONG $0xc8d7f9c5 // vpmovmskb %xmm0, %ecx + LONG $0xc474d1c5 // vpcmpeqb %xmm4, %xmm5, %xmm0 + LONG $0xd0d779c5 // vpmovmskb %xmm0, %r10d + LONG $0xc474c1c5 // vpcmpeqb %xmm4, %xmm7, %xmm0 + LONG $0xc0d779c5 // vpmovmskb %xmm0, %r8d + LONG $0xc474c9c5 // vpcmpeqb %xmm4, %xmm6, %xmm0 + LONG $0xe0d779c5 // vpmovmskb %xmm0, %r12d + LONG $0x30e4c149 // shlq $48, %r12 + LONG $0x20e0c149 // shlq $32, %r8 + LONG $0x10e2c149 // shlq $16, %r10 + WORD $0x094c; BYTE $0xd1 // orq %r10, %rcx + WORD $0x094c; BYTE $0xc1 // orq %r8, %rcx + WORD $0x094c; BYTE $0xe1 // orq %r12, %rcx + WORD $0x214c; BYTE $0xc9 // andq %r9, %rcx + LONG $0x003a840f; WORD $0x0000 // je LBB27_91, $58(%rip) + LONG $0x24448b4c; BYTE $0x18 // movq $24(%rsp), %r8 + QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90 -LBB32_82: - WORD $0x0148; BYTE $0xc2 // addq %rax, %rdx - WORD $0x8548; BYTE $0xc9 // testq %rcx, %rcx - LONG $0xf75d850f; WORD $0xffff // jne LBB32_7, $-2211(%rip) - LONG $0xfff78ce9; BYTE $0xff // jmp LBB32_13, $-2164(%rip) +LBB27_89: + LONG $0xff518d4c // leaq $-1(%rcx), %r10 + WORD $0x894c; BYTE $0xd2 // movq %r10, %rdx + WORD $0x214c; BYTE $0xfa // andq %r15, %rdx + LONG $0xb80f48f3; BYTE $0xd2 // popcntq %rdx, %rdx + WORD $0x014c; BYTE $0xc2 // addq %r8, %rdx + WORD $0x3948; BYTE $0xda // cmpq %rbx, %rdx + LONG $0x0050860f; WORD $0x0000 // jbe LBB27_108, $80(%rip) + WORD $0xff48; BYTE $0xc3 // incq %rbx + WORD $0x214c; BYTE $0xd1 // andq %r10, %rcx + LONG $0xffd9850f; WORD $0xffff // jne LBB27_89, $-39(%rip) + LONG $0x000005e9; BYTE $0x00 // jmp LBB27_92, $5(%rip) -LBB32_83: - LONG $0x084f8b49 // movq $8(%r15), %rcx - WORD $0x8949; BYTE $0x0e // movq %rcx, (%r14) - LONG $0xfff798e9; BYTE $0xff // jmp LBB32_16, $-2152(%rip) +LBB27_91: + LONG $0x24448b4c; BYTE $0x18 // movq $24(%rsp), %r8 -LBB32_84: - WORD $0x394d; BYTE $0xe9 // cmpq %r13, %r9 - LONG $0xf78f840f; WORD $0xffff // je LBB32_16, $-2161(%rip) - WORD $0x014d; BYTE $0xea // addq %r13, %r10 - WORD $0xff49; BYTE $0xc2 // incq %r10 - WORD $0xf749; BYTE $0xd5 // notq %r13 - WORD $0x014d; BYTE $0xe9 // addq %r13, %r9 - WORD $0x854d; BYTE $0xc9 // testq %r9, %r9 - LONG $0x0024850f; WORD $0x0000 // jne LBB32_88, $36(%rip) - LONG $0xfff775e9; BYTE $0xff // jmp LBB32_16, $-2187(%rip) +LBB27_92: + LONG $0x3ffdc149 // sarq $63, %r13 + LONG $0xb80f49f3; BYTE $0xcf // popcntq %r15, %rcx + WORD $0x0149; BYTE $0xc8 // addq %rcx, %r8 + LONG $0x40c68349 // addq $64, %r14 + LONG $0x244c8b48; BYTE $0x08 // movq $8(%rsp), %rcx + LONG $0xc0c18348 // addq $-64, %rcx + WORD $0x894d; BYTE $0xea // movq %r13, %r10 + LONG $0x247c8b4c; BYTE $0x10 // movq $16(%rsp), %r15 + LONG $0x40f98348 // cmpq $64, %rcx + LONG $0x244c8948; BYTE $0x08 // movq %rcx, $8(%rsp) + LONG $0x2444894c; BYTE $0x18 // movq %r8, $24(%rsp) + LONG $0xfe118d0f; WORD $0xffff // jge LBB27_84, $-495(%rip) + LONG $0xfffcd9e9; BYTE $0xff // jmp LBB27_93, $-807(%rip) -LBB32_86: +LBB27_108: + LONG $0x08478b48 // movq $8(%rdi), %rax + LONG $0xc9bc0f48 // bsfq %rcx, %rcx + LONG $0x244c2b48; BYTE $0x08 // subq $8(%rsp), %rcx + LONG $0x01448d48; BYTE $0x01 // leaq $1(%rcx,%rax), %rax + WORD $0x8948; BYTE $0x06 // movq %rax, (%rsi) + LONG $0x084f8b48 // movq $8(%rdi), %rcx + WORD $0x3948; BYTE $0xc8 // cmpq %rcx, %rax + LONG $0xc1470f48 // cmovaq %rcx, %rax + WORD $0x8948; BYTE $0x06 // movq %rax, (%rsi) + LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax + LONG $0xd8470f4c // cmovaq %rax, %r11 + LONG $0xfff787e9; BYTE $0xff // jmp LBB27_43, $-2169(%rip) + +LBB27_53: + WORD $0x854d; BYTE $0xe4 // testq %r12, %r12 + LONG $0x008e850f; WORD $0x0000 // jne LBB27_118, $142(%rip) + LONG $0x175c8d4b; BYTE $0x01 // leaq $1(%r15,%r10), %rbx + WORD $0xf749; BYTE $0xd7 // notq %r15 + WORD $0x014d; BYTE $0xc7 // addq %r8, %r15 + +LBB27_55: + WORD $0x854d; BYTE $0xff // testq %r15, %r15 + LONG $0x00248f0f; WORD $0x0000 // jg LBB27_112, $36(%rip) + LONG $0xfff768e9; BYTE $0xff // jmp LBB27_44, $-2200(%rip) + +LBB27_110: LONG $0xfec1c748; WORD $0xffff; BYTE $0xff // movq $-2, %rcx LONG $0x000002b8; BYTE $0x00 // movl $2, %eax - WORD $0x0149; BYTE $0xc2 // addq %rax, %r10 + WORD $0x0148; BYTE $0xc3 // addq %rax, %rbx LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax - WORD $0x0149; BYTE $0xc9 // addq %rcx, %r9 - LONG $0xf756840f; WORD $0xffff // je LBB32_16, $-2218(%rip) - -LBB32_88: - LONG $0x02b60f41 // movzbl (%r10), %eax - WORD $0xf883; BYTE $0x5c // cmpl $92, %eax - LONG $0xffd4840f; WORD $0xffff // je LBB32_86, $-44(%rip) - WORD $0xf883; BYTE $0x22 // cmpl $34, %eax - LONG $0x0024840f; WORD $0x0000 // je LBB32_91, $36(%rip) + WORD $0x0149; BYTE $0xcf // addq %rcx, %r15 + LONG $0xf7498e0f; WORD $0xffff // jle LBB27_44, $-2231(%rip) + +LBB27_112: + WORD $0xb60f; BYTE $0x03 // movzbl (%rbx), %eax + WORD $0x5c3c // cmpb $92, %al + LONG $0xffd6840f; WORD $0xffff // je LBB27_110, $-42(%rip) + WORD $0x223c // cmpb $34, %al + LONG $0x0024840f; WORD $0x0000 // je LBB27_115, $36(%rip) LONG $0xffc1c748; WORD $0xffff; BYTE $0xff // movq $-1, %rcx LONG $0x000001b8; BYTE $0x00 // movl $1, %eax - WORD $0x0149; BYTE $0xc2 // addq %rax, %r10 + WORD $0x0148; BYTE $0xc3 // addq %rax, %rbx LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax - WORD $0x0149; BYTE $0xc9 // addq %rcx, %r9 - LONG $0xffcb850f; WORD $0xffff // jne LBB32_88, $-53(%rip) - LONG $0xfff71ce9; BYTE $0xff // jmp LBB32_16, $-2276(%rip) - -LBB32_91: - LONG $0x24542b4c; BYTE $0x08 // subq $8(%rsp), %r10 - WORD $0xff49; BYTE $0xc2 // incq %r10 - WORD $0x894d; BYTE $0x16 // movq %r10, (%r14) - WORD $0x894c; BYTE $0xc0 // movq %r8, %rax - LONG $0xfff709e9; BYTE $0xff // jmp LBB32_16, $-2295(%rip) - BYTE $0x90 // .p2align 2, 0x90 + WORD $0x0149; BYTE $0xcf // addq %rcx, %r15 + LONG $0xffce8f0f; WORD $0xffff // jg LBB27_112, $-50(%rip) + LONG $0xfff712e9; BYTE $0xff // jmp LBB27_44, $-2286(%rip) + +LBB27_115: + WORD $0x294c; BYTE $0xf3 // subq %r14, %rbx + WORD $0xff48; BYTE $0xc3 // incq %rbx + LONG $0xfff701e9; BYTE $0xff // jmp LBB27_42, $-2303(%rip) + +LBB27_116: + WORD $0x014c; BYTE $0xf3 // addq %r14, %rbx + LONG $0xffff89e9; BYTE $0xff // jmp LBB27_55, $-119(%rip) + +LBB27_117: + LONG $0x084f8b48 // movq $8(%rdi), %rcx + WORD $0x8948; BYTE $0x0e // movq %rcx, (%rsi) + LONG $0xfff6f3e9; BYTE $0xff // jmp LBB27_44, $-2317(%rip) + +LBB27_118: + LONG $0xff488d49 // leaq $-1(%r8), %rcx + WORD $0x394c; BYTE $0xf9 // cmpq %r15, %rcx + LONG $0xf6e6840f; WORD $0xffff // je LBB27_44, $-2330(%rip) + LONG $0x175c8d4b; BYTE $0x02 // leaq $2(%r15,%r10), %rbx + WORD $0x294d; BYTE $0xf8 // subq %r15, %r8 + LONG $0xfec08349 // addq $-2, %r8 + WORD $0x894d; BYTE $0xc7 // movq %r8, %r15 + LONG $0xffff5ce9; BYTE $0xff // jmp LBB27_55, $-164(%rip) + WORD $0x9090 // .p2align 2, 0x90 + + // .set L27_0_set_44, LBB27_44-LJTI27_0 + // .set L27_0_set_46, LBB27_46-LJTI27_0 + // .set L27_0_set_47, LBB27_47-LJTI27_0 + // .set L27_0_set_29, LBB27_29-LJTI27_0 + // .set L27_0_set_56, LBB27_56-LJTI27_0 + // .set L27_0_set_81, LBB27_81-LJTI27_0 + // .set L27_0_set_45, LBB27_45-LJTI27_0 + // .set L27_0_set_83, LBB27_83-LJTI27_0 +LJTI27_0: + LONG $0xfffff6d0 // .long L27_0_set_44 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff704 // .long L27_0_set_47 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff613 // .long L27_0_set_29 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff613 // .long L27_0_set_29 + LONG $0xfffff613 // .long L27_0_set_29 + LONG $0xfffff613 // .long L27_0_set_29 + LONG $0xfffff613 // .long L27_0_set_29 + LONG $0xfffff613 // .long L27_0_set_29 + LONG $0xfffff613 // .long L27_0_set_29 + LONG $0xfffff613 // .long L27_0_set_29 + LONG $0xfffff613 // .long L27_0_set_29 + LONG $0xfffff613 // .long L27_0_set_29 + LONG $0xfffff613 // .long L27_0_set_29 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff80a // .long L27_0_set_56 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffffb83 // .long L27_0_set_81 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6e2 // .long L27_0_set_45 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6e2 // .long L27_0_set_45 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffff6f5 // .long L27_0_set_46 + LONG $0xfffffb99 // .long L27_0_set_83 + QUAD $0x0000000000000000 // .p2align 4, 0x00 - // .set L32_0_set_16, LBB32_16-LJTI32_0 - // .set L32_0_set_18, LBB32_18-LJTI32_0 - // .set L32_0_set_19, LBB32_19-LJTI32_0 - // .set L32_0_set_2, LBB32_2-LJTI32_0 - // .set L32_0_set_28, LBB32_28-LJTI32_0 - // .set L32_0_set_53, LBB32_53-LJTI32_0 - // .set L32_0_set_17, LBB32_17-LJTI32_0 - // .set L32_0_set_54, LBB32_54-LJTI32_0 -LJTI32_0: - LONG $0xfffff708 // .long L32_0_set_16 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff73c // .long L32_0_set_19 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff633 // .long L32_0_set_2 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff633 // .long L32_0_set_2 - LONG $0xfffff633 // .long L32_0_set_2 - LONG $0xfffff633 // .long L32_0_set_2 - LONG $0xfffff633 // .long L32_0_set_2 - LONG $0xfffff633 // .long L32_0_set_2 - LONG $0xfffff633 // .long L32_0_set_2 - LONG $0xfffff633 // .long L32_0_set_2 - LONG $0xfffff633 // .long L32_0_set_2 - LONG $0xfffff633 // .long L32_0_set_2 - LONG $0xfffff633 // .long L32_0_set_2 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff83c // .long L32_0_set_28 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffffb8d // .long L32_0_set_53 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff71a // .long L32_0_set_17 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff71a // .long L32_0_set_17 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffff72d // .long L32_0_set_18 - LONG $0xfffffba0 // .long L32_0_set_54 - QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90 +LCPI28_0: + LONG $0x00000001 // .long 1 + LONG $0x00000000 // .long 0 + LONG $0x00000000 // .long 0 + LONG $0x00000000 // .long 0 + // .p2align 4, 0x90 _get_by_path: - BYTE $0x55 // pushq %rbp - WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp - WORD $0x5741 // pushq %r15 - WORD $0x5641 // pushq %r14 - WORD $0x5541 // pushq %r13 - WORD $0x5441 // pushq %r12 - BYTE $0x53 // pushq %rbx - LONG $0x38ec8348 // subq $56, %rsp - WORD $0x8949; BYTE $0xf4 // movq %rsi, %r12 - WORD $0x8949; BYTE $0xfe // movq %rdi, %r14 - LONG $0x08428b48 // movq $8(%rdx), %rax - WORD $0x8548; BYTE $0xc0 // testq %rax, %rax - LONG $0x038d840f; WORD $0x0000 // je LBB33_53, $909(%rip) - WORD $0x8b4c; BYTE $0x3a // movq (%rdx), %r15 - LONG $0x04e0c148 // shlq $4, %rax - WORD $0x014c; BYTE $0xf8 // addq %r15, %rax - LONG $0xa0458948 // movq %rax, $-96(%rbp) - -LBB33_2: - WORD $0x8b49; BYTE $0x3e // movq (%r14), %rdi - LONG $0x08768b49 // movq $8(%r14), %rsi - WORD $0x894c; BYTE $0xe2 // movq %r12, %rdx - LONG $0xffd40fe8; BYTE $0xff // callq _advance_ns, $-11249(%rip) - WORD $0x8b49; BYTE $0x0f // movq (%r15), %rcx - LONG $0x1749b60f // movzbl $23(%rcx), %ecx - WORD $0xe180; BYTE $0x1f // andb $31, %cl - WORD $0xf980; BYTE $0x18 // cmpb $24, %cl - LONG $0x02ec850f; WORD $0x0000 // jne LBB33_47, $748(%rip) - WORD $0x7b3c // cmpb $123, %al - LONG $0xc865894c // movq %r12, $-56(%rbp) - LONG $0xd07d894c // movq %r15, $-48(%rbp) - LONG $0x035d850f; WORD $0x0000 // jne LBB33_54, $861(%rip) - QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90 + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5741 // pushq %r15 + WORD $0x5641 // pushq %r14 + WORD $0x5541 // pushq %r13 + WORD $0x5441 // pushq %r12 + BYTE $0x53 // pushq %rbx + LONG $0x38ec8348 // subq $56, %rsp + WORD $0x8949; BYTE $0xf5 // movq %rsi, %r13 + WORD $0x8949; BYTE $0xfb // movq %rdi, %r11 + LONG $0x08528b4c // movq $8(%rdx), %r10 + WORD $0x854d; BYTE $0xd2 // testq %r10, %r10 + LONG $0x0f10840f; WORD $0x0000 // je LBB28_243, $3856(%rip) + WORD $0x8b48; BYTE $0x02 // movq (%rdx), %rax + LONG $0x04e2c149 // shlq $4, %r10 + LONG $0xb8458948 // movq %rax, $-72(%rbp) + WORD $0x0149; BYTE $0xc2 // addq %rax, %r10 + WORD $0x8b4d; BYTE $0x0b // movq (%r11), %r9 + LONG $0x00558b49 // movq (%r13), %rdx + QUAD $0x000100002600bc49; WORD $0x0000 // movabsq $4294977024, %r12 + LONG $0xc05d894c // movq %r11, $-64(%rbp) + LONG $0xa04d8948 // movq %rcx, $-96(%rbp) + LONG $0xa855894c // movq %r10, $-88(%rbp) + +LBB28_2: + LONG $0x08438b4d // movq $8(%r11), %r8 + WORD $0x8948; BYTE $0xd7 // movq %rdx, %rdi + WORD $0x294c; BYTE $0xc7 // subq %r8, %rdi + LONG $0x0031830f; WORD $0x0000 // jae LBB28_7, $49(%rip) + LONG $0x11048a41 // movb (%r9,%rdx), %al + WORD $0x0d3c // cmpb $13, %al + LONG $0x0025840f; WORD $0x0000 // je LBB28_7, $37(%rip) + WORD $0x203c // cmpb $32, %al + LONG $0x001d840f; WORD $0x0000 // je LBB28_7, $29(%rip) + WORD $0xf704 // addb $-9, %al + WORD $0x013c // cmpb $1, %al + LONG $0x0013860f; WORD $0x0000 // jbe LBB28_7, $19(%rip) + WORD $0x8948; BYTE $0xd6 // movq %rdx, %rsi + LONG $0x0000fde9; BYTE $0x00 // jmp LBB28_28, $253(%rip) + QUAD $0x9090909090909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 -LBB33_4: - WORD $0x8b49; BYTE $0x3e // movq (%r14), %rdi - LONG $0x08768b49 // movq $8(%r14), %rsi - WORD $0x894c; BYTE $0xe2 // movq %r12, %rdx - LONG $0xffd3d1e8; BYTE $0xff // callq _advance_ns, $-11311(%rip) - WORD $0x223c // cmpb $34, %al - LONG $0x033a850f; WORD $0x0000 // jne LBB33_54, $826(%rip) - LONG $0x08478b49 // movq $8(%r15), %rax - WORD $0x8b4c; BYTE $0x28 // movq (%rax), %r13 - LONG $0x08788b4c // movq $8(%rax), %r15 +LBB28_7: + LONG $0x01728d48 // leaq $1(%rdx), %rsi + WORD $0x394c; BYTE $0xc6 // cmpq %r8, %rsi + LONG $0x0023830f; WORD $0x0000 // jae LBB28_11, $35(%rip) + LONG $0x31048a41 // movb (%r9,%rsi), %al + WORD $0x0d3c // cmpb $13, %al + LONG $0x0017840f; WORD $0x0000 // je LBB28_11, $23(%rip) + WORD $0x203c // cmpb $32, %al + LONG $0x000f840f; WORD $0x0000 // je LBB28_11, $15(%rip) + WORD $0xf704 // addb $-9, %al + WORD $0x013c // cmpb $1, %al + LONG $0x00c7870f; WORD $0x0000 // ja LBB28_28, $199(%rip) + LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB28_11: + LONG $0x02728d48 // leaq $2(%rdx), %rsi + WORD $0x394c; BYTE $0xc6 // cmpq %r8, %rsi + LONG $0x0023830f; WORD $0x0000 // jae LBB28_15, $35(%rip) + LONG $0x31048a41 // movb (%r9,%rsi), %al + WORD $0x0d3c // cmpb $13, %al + LONG $0x0017840f; WORD $0x0000 // je LBB28_15, $23(%rip) + WORD $0x203c // cmpb $32, %al + LONG $0x000f840f; WORD $0x0000 // je LBB28_15, $15(%rip) + WORD $0xf704 // addb $-9, %al + WORD $0x013c // cmpb $1, %al + LONG $0x0097870f; WORD $0x0000 // ja LBB28_28, $151(%rip) + LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB28_15: + LONG $0x03728d48 // leaq $3(%rdx), %rsi + WORD $0x394c; BYTE $0xc6 // cmpq %r8, %rsi + LONG $0x0023830f; WORD $0x0000 // jae LBB28_19, $35(%rip) + LONG $0x31048a41 // movb (%r9,%rsi), %al + WORD $0x0d3c // cmpb $13, %al + LONG $0x0017840f; WORD $0x0000 // je LBB28_19, $23(%rip) + WORD $0x203c // cmpb $32, %al + LONG $0x000f840f; WORD $0x0000 // je LBB28_19, $15(%rip) + WORD $0xf704 // addb $-9, %al + WORD $0x013c // cmpb $1, %al + LONG $0x0067870f; WORD $0x0000 // ja LBB28_28, $103(%rip) + LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB28_19: + LONG $0x04428d48 // leaq $4(%rdx), %rax + WORD $0x3949; BYTE $0xc0 // cmpq %rax, %r8 + LONG $0x0083860f; WORD $0x0000 // jbe LBB28_25, $131(%rip) + WORD $0x3949; BYTE $0xc0 // cmpq %rax, %r8 + LONG $0x0095840f; WORD $0x0000 // je LBB28_26, $149(%rip) + LONG $0x01048d4b // leaq (%r9,%r8), %rax + LONG $0x04c78348 // addq $4, %rdi + LONG $0x11748d49; BYTE $0x05 // leaq $5(%r9,%rdx), %rsi + QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB28_22: + LONG $0xff5ebe0f // movsbl $-1(%rsi), %ebx + WORD $0xfb83; BYTE $0x20 // cmpl $32, %ebx + LONG $0x0bae870f; WORD $0x0000 // ja LBB28_29, $2990(%rip) + LONG $0xdca30f49 // btq %rbx, %r12 + LONG $0x0ba4830f; WORD $0x0000 // jae LBB28_29, $2980(%rip) + WORD $0xff48; BYTE $0xc6 // incq %rsi + WORD $0xff48; BYTE $0xc7 // incq %rdi + LONG $0xffdd850f; WORD $0xffff // jne LBB28_22, $-35(%rip) + WORD $0x294c; BYTE $0xc8 // subq %r9, %rax + WORD $0x8948; BYTE $0xc6 // movq %rax, %rsi + WORD $0x394c; BYTE $0xc6 // cmpq %r8, %rsi + LONG $0x005b830f; WORD $0x0000 // jae LBB28_30, $91(%rip) + +LBB28_28: + LONG $0x01468d48 // leaq $1(%rsi), %rax + LONG $0x00458949 // movq %rax, (%r13) + LONG $0x31348a41 // movb (%r9,%rsi), %sil + LONG $0xb8558b48 // movq $-72(%rbp), %rdx + WORD $0x8b48; BYTE $0x12 // movq (%rdx), %rdx + WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx + LONG $0x0062850f; WORD $0x0000 // jne LBB28_31, $98(%rip) + LONG $0x000dece9; BYTE $0x00 // jmp LBB28_250, $3564(%rip) + QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB28_25: + LONG $0x00458949 // movq %rax, (%r13) + WORD $0xf631 // xorl %esi, %esi + LONG $0xb8558b48 // movq $-72(%rbp), %rdx + WORD $0x8b48; BYTE $0x12 // movq (%rdx), %rdx + WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx + LONG $0x003a850f; WORD $0x0000 // jne LBB28_31, $58(%rip) + LONG $0x000dc4e9; BYTE $0x00 // jmp LBB28_250, $3524(%rip) + +LBB28_26: + WORD $0x014c; BYTE $0xc8 // addq %r9, %rax + WORD $0x294c; BYTE $0xc8 // subq %r9, %rax + WORD $0x8948; BYTE $0xc6 // movq %rax, %rsi + WORD $0x394c; BYTE $0xc6 // cmpq %r8, %rsi + LONG $0xffa5820f; WORD $0xffff // jb LBB28_28, $-91(%rip) + +LBB28_30: + WORD $0xf631 // xorl %esi, %esi + WORD $0x8948; BYTE $0xd0 // movq %rdx, %rax + LONG $0xb8558b48 // movq $-72(%rbp), %rdx + WORD $0x8b48; BYTE $0x12 // movq (%rdx), %rdx + WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx + LONG $0x0d9d840f; WORD $0x0000 // je LBB28_250, $3485(%rip) + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 + +LBB28_31: + WORD $0x528a; BYTE $0x17 // movb $23(%rdx), %dl + WORD $0xe280; BYTE $0x1f // andb $31, %dl + WORD $0xfa80; BYTE $0x02 // cmpb $2, %dl + LONG $0x0021840f; WORD $0x0000 // je LBB28_183, $33(%rip) + WORD $0xfa80; BYTE $0x18 // cmpb $24, %dl + LONG $0x0d77850f; WORD $0x0000 // jne LBB28_250, $3447(%rip) + LONG $0x7bfe8040 // cmpb $123, %sil + LONG $0xc86d894c // movq %r13, $-56(%rbp) + LONG $0x0179840f; WORD $0x0000 // je LBB28_34, $377(%rip) + LONG $0x000d34e9; BYTE $0x00 // jmp LBB28_246, $3380(%rip) + LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB28_183: + LONG $0x5bfe8040 // cmpb $91, %sil + LONG $0x0d25850f; WORD $0x0000 // jne LBB28_246, $3365(%rip) + LONG $0xb8558b48 // movq $-72(%rbp), %rdx + LONG $0x08528b48 // movq $8(%rdx), %rdx + WORD $0x8b4c; BYTE $0x32 // movq (%rdx), %r14 + WORD $0x854d; BYTE $0xf6 // testq %r14, %r14 + LONG $0x0d41880f; WORD $0x0000 // js LBB28_250, $3393(%rip) + LONG $0x08438b4d // movq $8(%r11), %r8 + WORD $0x8948; BYTE $0xc6 // movq %rax, %rsi + WORD $0x294c; BYTE $0xc6 // subq %r8, %rsi + LONG $0x0032830f; WORD $0x0000 // jae LBB28_190, $50(%rip) + LONG $0x01148a41 // movb (%r9,%rax), %dl + WORD $0xfa80; BYTE $0x0d // cmpb $13, %dl + LONG $0x0025840f; WORD $0x0000 // je LBB28_190, $37(%rip) + WORD $0xfa80; BYTE $0x20 // cmpb $32, %dl + LONG $0x001c840f; WORD $0x0000 // je LBB28_190, $28(%rip) + WORD $0xc280; BYTE $0xf7 // addb $-9, %dl + WORD $0xfa80; BYTE $0x01 // cmpb $1, %dl + LONG $0x0010860f; WORD $0x0000 // jbe LBB28_190, $16(%rip) + WORD $0x8948; BYTE $0xc7 // movq %rax, %rdi + LONG $0x000ac3e9; BYTE $0x00 // jmp LBB28_212, $2755(%rip) + QUAD $0x9090909090909090 // .p2align 4, 0x90 + +LBB28_190: + LONG $0x01788d48 // leaq $1(%rax), %rdi + WORD $0x394c; BYTE $0xc7 // cmpq %r8, %rdi + LONG $0x0023830f; WORD $0x0000 // jae LBB28_194, $35(%rip) + LONG $0x39148a41 // movb (%r9,%rdi), %dl + WORD $0xfa80; BYTE $0x0d // cmpb $13, %dl + LONG $0x0016840f; WORD $0x0000 // je LBB28_194, $22(%rip) + WORD $0xfa80; BYTE $0x20 // cmpb $32, %dl + LONG $0x000d840f; WORD $0x0000 // je LBB28_194, $13(%rip) + WORD $0xc280; BYTE $0xf7 // addb $-9, %dl + WORD $0xfa80; BYTE $0x01 // cmpb $1, %dl + LONG $0x0a8c870f; WORD $0x0000 // ja LBB28_212, $2700(%rip) + BYTE $0x90 // .p2align 4, 0x90 + +LBB28_194: + LONG $0x02788d48 // leaq $2(%rax), %rdi + WORD $0x394c; BYTE $0xc7 // cmpq %r8, %rdi + LONG $0x0023830f; WORD $0x0000 // jae LBB28_198, $35(%rip) + LONG $0x39148a41 // movb (%r9,%rdi), %dl + WORD $0xfa80; BYTE $0x0d // cmpb $13, %dl + LONG $0x0016840f; WORD $0x0000 // je LBB28_198, $22(%rip) + WORD $0xfa80; BYTE $0x20 // cmpb $32, %dl + LONG $0x000d840f; WORD $0x0000 // je LBB28_198, $13(%rip) + WORD $0xc280; BYTE $0xf7 // addb $-9, %dl + WORD $0xfa80; BYTE $0x01 // cmpb $1, %dl + LONG $0x0a5c870f; WORD $0x0000 // ja LBB28_212, $2652(%rip) + BYTE $0x90 // .p2align 4, 0x90 + +LBB28_198: + LONG $0x03788d48 // leaq $3(%rax), %rdi + WORD $0x394c; BYTE $0xc7 // cmpq %r8, %rdi + LONG $0x0023830f; WORD $0x0000 // jae LBB28_202, $35(%rip) + LONG $0x39148a41 // movb (%r9,%rdi), %dl + WORD $0xfa80; BYTE $0x0d // cmpb $13, %dl + LONG $0x0016840f; WORD $0x0000 // je LBB28_202, $22(%rip) + WORD $0xfa80; BYTE $0x20 // cmpb $32, %dl + LONG $0x000d840f; WORD $0x0000 // je LBB28_202, $13(%rip) + WORD $0xc280; BYTE $0xf7 // addb $-9, %dl + WORD $0xfa80; BYTE $0x01 // cmpb $1, %dl + LONG $0x0a2c870f; WORD $0x0000 // ja LBB28_212, $2604(%rip) + BYTE $0x90 // .p2align 4, 0x90 + +LBB28_202: + LONG $0x04508d48 // leaq $4(%rax), %rdx + WORD $0x3949; BYTE $0xd0 // cmpq %rdx, %r8 + LONG $0x09d2860f; WORD $0x0000 // jbe LBB28_208, $2514(%rip) + WORD $0x3949; BYTE $0xd0 // cmpq %rdx, %r8 + LONG $0x09ec840f; WORD $0x0000 // je LBB28_209, $2540(%rip) + LONG $0x01148d4b // leaq (%r9,%r8), %rdx + LONG $0x04c68348 // addq $4, %rsi + LONG $0x017c8d49; BYTE $0x05 // leaq $5(%r9,%rax), %rdi + QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB28_205: + LONG $0xff4fbe0f // movsbl $-1(%rdi), %ecx + WORD $0xf983; BYTE $0x20 // cmpl $32, %ecx + LONG $0x09dc870f; WORD $0x0000 // ja LBB28_211, $2524(%rip) + LONG $0xcca30f49 // btq %rcx, %r12 + LONG $0x09d2830f; WORD $0x0000 // jae LBB28_211, $2514(%rip) + WORD $0xff48; BYTE $0xc7 // incq %rdi + WORD $0xff48; BYTE $0xc6 // incq %rsi + LONG $0xffdd850f; WORD $0xffff // jne LBB28_205, $-35(%rip) + LONG $0x0009ade9; BYTE $0x00 // jmp LBB28_210, $2477(%rip) + +LBB28_179: + WORD $0x894c; BYTE $0xca // movq %r9, %rdx + WORD $0xf748; BYTE $0xd2 // notq %rdx + WORD $0x0148; BYTE $0xd7 // addq %rdx, %rdi + WORD $0x3948; BYTE $0xcf // cmpq %rcx, %rdi + LONG $0x0bd5830f; WORD $0x0000 // jae LBB28_246, $3029(%rip) + +LBB28_180: + LONG $0x01478d48 // leaq $1(%rdi), %rax + LONG $0x00458949 // movq %rax, (%r13) + LONG $0x390c8a41 // movb (%r9,%rdi), %cl + WORD $0xf980; BYTE $0x2c // cmpb $44, %cl + LONG $0x0c06850f; WORD $0x0000 // jne LBB28_252, $3078(%rip) + +LBB28_34: + LONG $0x084b8b49 // movq $8(%r11), %rcx + WORD $0x8948; BYTE $0xc6 // movq %rax, %rsi + WORD $0x2948; BYTE $0xce // subq %rcx, %rsi + LONG $0x0031830f; WORD $0x0000 // jae LBB28_39, $49(%rip) + LONG $0x01148a41 // movb (%r9,%rax), %dl + WORD $0xfa80; BYTE $0x0d // cmpb $13, %dl + LONG $0x0024840f; WORD $0x0000 // je LBB28_39, $36(%rip) + WORD $0xfa80; BYTE $0x20 // cmpb $32, %dl + LONG $0x001b840f; WORD $0x0000 // je LBB28_39, $27(%rip) + WORD $0xc280; BYTE $0xf7 // addb $-9, %dl + WORD $0xfa80; BYTE $0x01 // cmpb $1, %dl + LONG $0x000f860f; WORD $0x0000 // jbe LBB28_39, $15(%rip) + WORD $0x8949; BYTE $0xc7 // movq %rax, %r15 + LONG $0x000129e9; BYTE $0x00 // jmp LBB28_60, $297(%rip) + LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB28_39: + LONG $0x01788d4c // leaq $1(%rax), %r15 + WORD $0x3949; BYTE $0xcf // cmpq %rcx, %r15 + LONG $0x0023830f; WORD $0x0000 // jae LBB28_43, $35(%rip) + LONG $0x39148a43 // movb (%r9,%r15), %dl + WORD $0xfa80; BYTE $0x0d // cmpb $13, %dl + LONG $0x0016840f; WORD $0x0000 // je LBB28_43, $22(%rip) + WORD $0xfa80; BYTE $0x20 // cmpb $32, %dl + LONG $0x000d840f; WORD $0x0000 // je LBB28_43, $13(%rip) + WORD $0xc280; BYTE $0xf7 // addb $-9, %dl + WORD $0xfa80; BYTE $0x01 // cmpb $1, %dl + LONG $0x00f3870f; WORD $0x0000 // ja LBB28_60, $243(%rip) + BYTE $0x90 // .p2align 4, 0x90 + +LBB28_43: + LONG $0x02788d4c // leaq $2(%rax), %r15 + WORD $0x3949; BYTE $0xcf // cmpq %rcx, %r15 + LONG $0x0023830f; WORD $0x0000 // jae LBB28_47, $35(%rip) + LONG $0x39148a43 // movb (%r9,%r15), %dl + WORD $0xfa80; BYTE $0x0d // cmpb $13, %dl + LONG $0x0016840f; WORD $0x0000 // je LBB28_47, $22(%rip) + WORD $0xfa80; BYTE $0x20 // cmpb $32, %dl + LONG $0x000d840f; WORD $0x0000 // je LBB28_47, $13(%rip) + WORD $0xc280; BYTE $0xf7 // addb $-9, %dl + WORD $0xfa80; BYTE $0x01 // cmpb $1, %dl + LONG $0x00c3870f; WORD $0x0000 // ja LBB28_60, $195(%rip) + BYTE $0x90 // .p2align 4, 0x90 + +LBB28_47: + LONG $0x03788d4c // leaq $3(%rax), %r15 + WORD $0x3949; BYTE $0xcf // cmpq %rcx, %r15 + LONG $0x0023830f; WORD $0x0000 // jae LBB28_51, $35(%rip) + LONG $0x39148a43 // movb (%r9,%r15), %dl + WORD $0xfa80; BYTE $0x0d // cmpb $13, %dl + LONG $0x0016840f; WORD $0x0000 // je LBB28_51, $22(%rip) + WORD $0xfa80; BYTE $0x20 // cmpb $32, %dl + LONG $0x000d840f; WORD $0x0000 // je LBB28_51, $13(%rip) + WORD $0xc280; BYTE $0xf7 // addb $-9, %dl + WORD $0xfa80; BYTE $0x01 // cmpb $1, %dl + LONG $0x0093870f; WORD $0x0000 // ja LBB28_60, $147(%rip) + BYTE $0x90 // .p2align 4, 0x90 + +LBB28_51: + LONG $0x04508d48 // leaq $4(%rax), %rdx + WORD $0x3948; BYTE $0xd1 // cmpq %rdx, %rcx + LONG $0x0adb860f; WORD $0x0000 // jbe LBB28_244, $2779(%rip) + WORD $0x3948; BYTE $0xd1 // cmpq %rdx, %rcx + LONG $0x004a840f; WORD $0x0000 // je LBB28_57, $74(%rip) + LONG $0x09148d49 // leaq (%r9,%rcx), %rdx + LONG $0x04c68348 // addq $4, %rsi + LONG $0x017c8d4d; BYTE $0x05 // leaq $5(%r9,%rax), %r15 + QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB28_54: + LONG $0x7fbe0f41; BYTE $0xff // movsbl $-1(%r15), %edi + WORD $0xff83; BYTE $0x20 // cmpl $32, %edi + LONG $0x0042870f; WORD $0x0000 // ja LBB28_59, $66(%rip) + LONG $0xfca30f49 // btq %rdi, %r12 + LONG $0x0038830f; WORD $0x0000 // jae LBB28_59, $56(%rip) + WORD $0xff49; BYTE $0xc7 // incq %r15 + WORD $0xff48; BYTE $0xc6 // incq %rsi + LONG $0xffdc850f; WORD $0xffff // jne LBB28_54, $-36(%rip) + LONG $0x00000ae9; BYTE $0x00 // jmp LBB28_58, $10(%rip) + LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB28_57: + WORD $0x014c; BYTE $0xca // addq %r9, %rdx + +LBB28_58: + WORD $0x294c; BYTE $0xca // subq %r9, %rdx + WORD $0x8949; BYTE $0xd7 // movq %rdx, %r15 + WORD $0x3949; BYTE $0xcf // cmpq %rcx, %r15 + LONG $0x0020820f; WORD $0x0000 // jb LBB28_60, $32(%rip) + LONG $0x000a78e9; BYTE $0x00 // jmp LBB28_246, $2680(%rip) + QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB28_59: + WORD $0x894c; BYTE $0xca // movq %r9, %rdx + WORD $0xf748; BYTE $0xd2 // notq %rdx + WORD $0x0149; BYTE $0xd7 // addq %rdx, %r15 + WORD $0x3949; BYTE $0xcf // cmpq %rcx, %r15 + LONG $0x0a5d830f; WORD $0x0000 // jae LBB28_246, $2653(%rip) + +LBB28_60: + LONG $0x015f8d49 // leaq $1(%r15), %rbx + LONG $0x005d8949 // movq %rbx, (%r13) + LONG $0x390c8a43 // movb (%r9,%r15), %cl + WORD $0xf980; BYTE $0x22 // cmpb $34, %cl + LONG $0x0a8b850f; WORD $0x0000 // jne LBB28_251, $2699(%rip) + LONG $0xb8458b48 // movq $-72(%rbp), %rax + LONG $0x08408b48 // movq $8(%rax), %rax + WORD $0x8b4c; BYTE $0x30 // movq (%rax), %r14 + LONG $0x08688b4c // movq $8(%rax), %r13 QUAD $0xffffffffb045c748 // movq $-1, $-80(%rbp) - WORD $0x894c; BYTE $0xe3 // movq %r12, %rbx - LONG $0x24248b4d // movq (%r12), %r12 - WORD $0x894c; BYTE $0xf7 // movq %r14, %rdi - WORD $0x894c; BYTE $0xe6 // movq %r12, %rsi + WORD $0x894c; BYTE $0xdf // movq %r11, %rdi + WORD $0x8948; BYTE $0xde // movq %rbx, %rsi LONG $0xb0558d48 // leaq $-80(%rbp), %rdx - LONG $0x001c40e8; BYTE $0x00 // callq _advance_string_default, $7232(%rip) + LONG $0x0022c3e8; BYTE $0x00 // callq _advance_string_default, $8899(%rip) WORD $0x8548; BYTE $0xc0 // testq %rax, %rax - LONG $0x0322880f; WORD $0x0000 // js LBB33_56, $802(%rip) - WORD $0x8948; BYTE $0x03 // movq %rax, (%rbx) + LONG $0x0a7b880f; WORD $0x0000 // js LBB28_254, $2683(%rip) + LONG $0xc84d8b48 // movq $-56(%rbp), %rcx + WORD $0x8948; BYTE $0x01 // movq %rax, (%rcx) LONG $0xb04d8b48 // movq $-80(%rbp), %rcx LONG $0xfff98348 // cmpq $-1, %rcx - LONG $0x0009840f; WORD $0x0000 // je LBB33_8, $9(%rip) + LONG $0x0009840f; WORD $0x0000 // je LBB28_64, $9(%rip) WORD $0x3948; BYTE $0xc1 // cmpq %rax, %rcx - LONG $0x01578e0f; WORD $0x0000 // jle LBB33_27, $343(%rip) + LONG $0x01308e0f; WORD $0x0000 // jle LBB28_84, $304(%rip) -LBB33_8: - WORD $0x894c; BYTE $0xe1 // movq %r12, %rcx - WORD $0xf748; BYTE $0xd1 // notq %rcx - WORD $0x0148; BYTE $0xc8 // addq %rcx, %rax - WORD $0x394c; BYTE $0xf8 // cmpq %r15, %rax - LONG $0x003e850f; WORD $0x0000 // jne LBB33_12, $62(%rip) - WORD $0x034d; BYTE $0x26 // addq (%r14), %r12 - WORD $0x894c; BYTE $0xe9 // movq %r13, %rcx - WORD $0x894c; BYTE $0xe0 // movq %r12, %rax - WORD $0x9090 // .p2align 4, 0x90 +LBB28_64: + WORD $0x8948; BYTE $0xc2 // movq %rax, %rdx + WORD $0x294c; BYTE $0xfa // subq %r15, %rdx + LONG $0xfec28348 // addq $-2, %rdx + LONG $0x0001ba41; WORD $0x0000 // movl $1, %r10d + WORD $0x8948; BYTE $0xd1 // movq %rdx, %rcx + WORD $0x094c; BYTE $0xe9 // orq %r13, %rcx + LONG $0xc05d8b4c // movq $-64(%rbp), %r11 + LONG $0x00cf840f; WORD $0x0000 // je LBB28_79, $207(%rip) + WORD $0x394c; BYTE $0xea // cmpq %r13, %rdx + LONG $0x00c3850f; WORD $0x0000 // jne LBB28_78, $195(%rip) + WORD $0x0349; BYTE $0x1b // addq (%r11), %rbx + LONG $0x10fd8349 // cmpq $16, %r13 + LONG $0x0033820f; WORD $0x0000 // jb LBB28_69, $51(%rip) + LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 -LBB33_10: - LONG $0x10ff8349 // cmpq $16, %r15 - LONG $0x0086820f; WORD $0x0000 // jb LBB33_17, $134(%rip) - LONG $0x006ffac5 // vmovdqu (%rax), %xmm0 - LONG $0xf879c1c4; WORD $0x0045 // vpsubb (%r13), %xmm0, %xmm0 - LONG $0x10c08348 // addq $16, %rax - LONG $0x10c58349 // addq $16, %r13 - LONG $0xf0c78349 // addq $-16, %r15 - LONG $0x10c18348 // addq $16, %rcx - LONG $0x10c48349 // addq $16, %r12 - LONG $0x1779e2c4; BYTE $0xc0 // vptest %xmm0, %xmm0 - LONG $0xffcd840f; WORD $0xffff // je LBB33_10, $-51(%rip) +LBB28_67: + LONG $0x036ffac5 // vmovdqu (%rbx), %xmm0 + LONG $0x7479c1c4; BYTE $0x06 // vpcmpeqb (%r14), %xmm0, %xmm0 + LONG $0xc8d7f9c5 // vpmovmskb %xmm0, %ecx + LONG $0xfff98366 // cmpw $-1, %cx + LONG $0x0099850f; WORD $0x0000 // jne LBB28_78, $153(%rip) + LONG $0x10c38348 // addq $16, %rbx + LONG $0x10c68349 // addq $16, %r14 + LONG $0xf0c58349 // addq $-16, %r13 + LONG $0x0ffd8349 // cmpq $15, %r13 + LONG $0xffd3870f; WORD $0xffff // ja LBB28_67, $-45(%rip) -LBB33_12: - WORD $0xdb31 // xorl %ebx, %ebx +LBB28_69: + WORD $0x8944; BYTE $0xf1 // movl %r14d, %ecx + LONG $0x0fffe181; WORD $0x0000 // andl $4095, %ecx + LONG $0x0ff0f981; WORD $0x0000 // cmpl $4080, %ecx + LONG $0x0042870f; WORD $0x0000 // ja LBB28_73, $66(%rip) + WORD $0xd989 // movl %ebx, %ecx + LONG $0x0fffe181; WORD $0x0000 // andl $4095, %ecx + LONG $0x0ff1f981; WORD $0x0000 // cmpl $4081, %ecx + LONG $0x002e830f; WORD $0x0000 // jae LBB28_73, $46(%rip) + LONG $0x036ffac5 // vmovdqu (%rbx), %xmm0 + LONG $0x7479c1c4; BYTE $0x06 // vpcmpeqb (%r14), %xmm0, %xmm0 + LONG $0xc8d7f9c5 // vpmovmskb %xmm0, %ecx + LONG $0xfff98366 // cmpw $-1, %cx + WORD $0x940f; BYTE $0xc2 // sete %dl + WORD $0xd1f7 // notl %ecx + WORD $0xb70f; BYTE $0xc9 // movzwl %cx, %ecx + LONG $0xc9bc0f48 // bsfq %rcx, %rcx + WORD $0x394c; BYTE $0xe9 // cmpq %r13, %rcx + WORD $0x930f; BYTE $0xc1 // setae %cl + WORD $0xd108 // orb %dl, %cl + LONG $0xd1b60f44 // movzbl %cl, %r10d + LONG $0x00002fe9; BYTE $0x00 // jmp LBB28_79, $47(%rip) -LBB33_13: - LONG $0xc8658b4c // movq $-56(%rbp), %r12 +LBB28_73: + WORD $0x854d; BYTE $0xed // testq %r13, %r13 + LONG $0x0026840f; WORD $0x0000 // je LBB28_79, $38(%rip) + WORD $0xd231 // xorl %edx, %edx + BYTE $0x90 // .p2align 4, 0x90 -LBB33_14: - LONG $0xd07d8b4c // movq $-48(%rbp), %r15 - WORD $0x8b49; BYTE $0x3e // movq (%r14), %rdi - LONG $0x08768b49 // movq $8(%r14), %rsi - WORD $0x894c; BYTE $0xe2 // movq %r12, %rdx - LONG $0xffd314e8; BYTE $0xff // callq _advance_ns, $-11500(%rip) - WORD $0x3a3c // cmpb $58, %al - LONG $0x027d850f; WORD $0x0000 // jne LBB33_54, $637(%rip) - WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx - LONG $0x0253850f; WORD $0x0000 // jne LBB33_52, $595(%rip) - WORD $0x894c; BYTE $0xf7 // movq %r14, %rdi - WORD $0x894c; BYTE $0xe6 // movq %r12, %rsi - LONG $0xfff288e8; BYTE $0xff // callq _skip_one_fast, $-3448(%rip) - WORD $0x8b49; BYTE $0x3e // movq (%r14), %rdi - LONG $0x08768b49 // movq $8(%r14), %rsi - WORD $0x894c; BYTE $0xe2 // movq %r12, %rdx - LONG $0xffd2e9e8; BYTE $0xff // callq _advance_ns, $-11543(%rip) - WORD $0x2c3c // cmpb $44, %al - LONG $0xff01840f; WORD $0xffff // je LBB33_4, $-255(%rip) - LONG $0x00024de9; BYTE $0x00 // jmp LBB33_54, $589(%rip) - QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90 +LBB28_75: + LONG $0x130cb60f // movzbl (%rbx,%rdx), %ecx + LONG $0x160c3a41 // cmpb (%r14,%rdx), %cl + LONG $0x0012850f; WORD $0x0000 // jne LBB28_78, $18(%rip) + WORD $0xff48; BYTE $0xc2 // incq %rdx + WORD $0x3949; BYTE $0xd5 // cmpq %rdx, %r13 + LONG $0xffe6850f; WORD $0xffff // jne LBB28_75, $-26(%rip) + LONG $0x000004e9; BYTE $0x00 // jmp LBB28_79, $4(%rip) + BYTE $0x90 // .p2align 4, 0x90 -LBB33_17: - LONG $0xffe48141; WORD $0x000f; BYTE $0x00 // andl $4095, %r12d - LONG $0xf0fc8141; WORD $0x000f; BYTE $0x00 // cmpl $4080, %r12d - LONG $0x004d870f; WORD $0x0000 // ja LBB33_21, $77(%rip) - LONG $0x0fffe181; WORD $0x0000 // andl $4095, %ecx - LONG $0x0ff1f981; WORD $0x0000 // cmpl $4081, %ecx - LONG $0x003b830f; WORD $0x0000 // jae LBB33_21, $59(%rip) - LONG $0x006ffac5 // vmovdqu (%rax), %xmm0 - LONG $0x6f7ac1c4; WORD $0x004d // vmovdqu (%r13), %xmm1 - LONG $0xd1f8f9c5 // vpsubb %xmm1, %xmm0, %xmm2 - LONG $0x1779e2c4; BYTE $0xd2 // vptest %xmm2, %xmm2 - LONG $0xc8658b4c // movq $-56(%rbp), %r12 - LONG $0x005d840f; WORD $0x0000 // je LBB33_25, $93(%rip) - LONG $0xc174f9c5 // vpcmpeqb %xmm1, %xmm0, %xmm0 - LONG $0xc0d7f9c5 // vpmovmskb %xmm0, %eax - WORD $0xd0f7 // notl %eax - LONG $0xc0bc0f66 // bsfw %ax, %ax - WORD $0xb70f; BYTE $0xc0 // movzwl %ax, %eax - WORD $0xdb31 // xorl %ebx, %ebx - WORD $0x3949; BYTE $0xc7 // cmpq %rax, %r15 - WORD $0x960f; BYTE $0xc3 // setbe %bl - LONG $0xffff48e9; BYTE $0xff // jmp LBB33_14, $-184(%rip) - -LBB33_21: - LONG $0x000001bb; BYTE $0x00 // movl $1, %ebx - WORD $0x854d; BYTE $0xff // testq %r15, %r15 - LONG $0xc8658b4c // movq $-56(%rbp), %r12 - LONG $0xff36840f; WORD $0xffff // je LBB33_14, $-202(%rip) - WORD $0xc931 // xorl %ecx, %ecx - QUAD $0x9090909090909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 +LBB28_78: + WORD $0x3145; BYTE $0xd2 // xorl %r10d, %r10d -LBB33_23: - LONG $0x0814b60f // movzbl (%rax,%rcx), %edx - LONG $0x0d543a41; BYTE $0x00 // cmpb (%r13,%rcx), %dl - LONG $0x011d850f; WORD $0x0000 // jne LBB33_26, $285(%rip) - WORD $0xff48; BYTE $0xc1 // incq %rcx - WORD $0x3949; BYTE $0xcf // cmpq %rcx, %r15 - LONG $0xffe5850f; WORD $0xffff // jne LBB33_23, $-27(%rip) - LONG $0xffff09e9; BYTE $0xff // jmp LBB33_14, $-247(%rip) +LBB28_79: + WORD $0x8b4d; BYTE $0x0b // movq (%r11), %r9 + LONG $0xc86d8b4c // movq $-56(%rbp), %r13 + LONG $0x08738b49 // movq $8(%r11), %rsi + WORD $0x8948; BYTE $0xc7 // movq %rax, %rdi + WORD $0x2948; BYTE $0xf7 // subq %rsi, %rdi + LONG $0x03f6830f; WORD $0x0000 // jae LBB28_131, $1014(%rip) + +LBB28_80: + LONG $0x01148a41 // movb (%r9,%rax), %dl + WORD $0xfa80; BYTE $0x0d // cmpb $13, %dl + LONG $0x03e9840f; WORD $0x0000 // je LBB28_131, $1001(%rip) + WORD $0xfa80; BYTE $0x20 // cmpb $32, %dl + LONG $0x03e0840f; WORD $0x0000 // je LBB28_131, $992(%rip) + WORD $0xc280; BYTE $0xf7 // addb $-9, %dl + WORD $0xfa80; BYTE $0x01 // cmpb $1, %dl + LONG $0x03d4860f; WORD $0x0000 // jbe LBB28_131, $980(%rip) + WORD $0x8948; BYTE $0xc3 // movq %rax, %rbx + LONG $0x0004eee9; BYTE $0x00 // jmp LBB28_152, $1262(%rip) + +LBB28_84: + QUAD $0x00000000d045c748 // movq $0, $-48(%rbp) + LONG $0xc04d8b48 // movq $-64(%rbp), %rcx + WORD $0x8b4c; BYTE $0x09 // movq (%rcx), %r9 + WORD $0x014c; BYTE $0xcb // addq %r9, %rbx + LONG $0x01448d4d; BYTE $0xff // leaq $-1(%r9,%rax), %r8 + LONG $0x2e1c8d4f // leaq (%r14,%r13), %r11 + WORD $0x854d; BYTE $0xed // testq %r13, %r13 + LONG $0x037a8e0f; WORD $0x0000 // jle LBB28_128, $890(%rip) + WORD $0x3949; BYTE $0xd8 // cmpq %rbx, %r8 + LONG $0xc86d8b4c // movq $-56(%rbp), %r13 + LONG $0x0371860f; WORD $0x0000 // jbe LBB28_129, $881(%rip) + +LBB28_86: + WORD $0x0b8a // movb (%rbx), %cl + WORD $0xf980; BYTE $0x5c // cmpb $92, %cl + LONG $0x0058850f; WORD $0x0000 // jne LBB28_91, $88(%rip) + WORD $0x894c; BYTE $0xc2 // movq %r8, %rdx + WORD $0x2948; BYTE $0xda // subq %rbx, %rdx + LONG $0xffc1c748; WORD $0xffff; BYTE $0xff // movq $-1, %rcx + WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx + LONG $0x09188e0f; WORD $0x0000 // jle LBB28_258, $2328(%rip) + LONG $0x0173b60f // movzbl $1(%rbx), %esi + LONG $0x0f3d8d48; WORD $0x0099; BYTE $0x00 // leaq $39183(%rip), %rdi /* __UnquoteTab(%rip) */ + LONG $0x3e3c8a44 // movb (%rsi,%rdi), %r15b + LONG $0xffff8041 // cmpb $-1, %r15b + LONG $0x003d840f; WORD $0x0000 // je LBB28_93, $61(%rip) + WORD $0x8445; BYTE $0xff // testb %r15b, %r15b + LONG $0x08e4840f; WORD $0x0000 // je LBB28_256, $2276(%rip) + LONG $0xd07d8844 // movb %r15b, $-48(%rbp) + LONG $0x02c38348 // addq $2, %rbx + LONG $0x000001ba; BYTE $0x00 // movl $1, %edx + LONG $0x15548d4c; BYTE $0xd0 // leaq $-48(%rbp,%rdx), %r10 + WORD $0x394d; BYTE $0xde // cmpq %r11, %r14 + LONG $0x0130820f; WORD $0x0000 // jb LBB28_104, $304(%rip) + LONG $0x0002e6e9; BYTE $0x00 // jmp LBB28_112, $742(%rip) + +LBB28_91: + WORD $0x3a41; BYTE $0x0e // cmpb (%r14), %cl + LONG $0x05c6850f; WORD $0x0000 // jne LBB28_182, $1478(%rip) + WORD $0xff48; BYTE $0xc3 // incq %rbx + WORD $0xff49; BYTE $0xc6 // incq %r14 + LONG $0x0002dfe9; BYTE $0x00 // jmp LBB28_114, $735(%rip) -LBB33_25: - LONG $0x000001bb; BYTE $0x00 // movl $1, %ebx - LONG $0xfffeffe9; BYTE $0xff // jmp LBB33_14, $-257(%rip) +LBB28_93: + LONG $0x03fa8348 // cmpq $3, %rdx + LONG $0x08b58e0f; WORD $0x0000 // jle LBB28_257, $2229(%rip) + WORD $0x4b8b; BYTE $0x02 // movl $2(%rbx), %ecx + WORD $0xce89 // movl %ecx, %esi + WORD $0xd6f7 // notl %esi + LONG $0xcfd0b98d; WORD $0xcfcf // leal $-808464432(%rcx), %edi + LONG $0x8080e681; WORD $0x8080 // andl $-2139062144, %esi + WORD $0xfe85 // testl %edi, %esi + LONG $0x087b850f; WORD $0x0000 // jne LBB28_255, $2171(%rip) + LONG $0x1919b98d; WORD $0x1919 // leal $421075225(%rcx), %edi + WORD $0xcf09 // orl %ecx, %edi + LONG $0x8080c7f7; WORD $0x8080 // testl $-2139062144, %edi + LONG $0x0867850f; WORD $0x0000 // jne LBB28_255, $2151(%rip) + WORD $0xcf89 // movl %ecx, %edi + LONG $0x7f7fe781; WORD $0x7f7f // andl $2139062143, %edi + LONG $0xc0c0ba41; WORD $0xc0c0 // movl $-1061109568, %r10d + WORD $0x2941; BYTE $0xfa // subl %edi, %r10d + LONG $0x46bf8d44; WORD $0x4646; BYTE $0x46 // leal $1179010630(%rdi), %r15d + WORD $0x2141; BYTE $0xf2 // andl %esi, %r10d + WORD $0x8545; BYTE $0xfa // testl %r15d, %r10d + LONG $0x0843850f; WORD $0x0000 // jne LBB28_255, $2115(%rip) + LONG $0xe0e0ba41; WORD $0xe0e0 // movl $-522133280, %r10d + WORD $0x2941; BYTE $0xfa // subl %edi, %r10d + LONG $0x3939c781; WORD $0x3939 // addl $960051513, %edi + WORD $0x2144; BYTE $0xd6 // andl %r10d, %esi + WORD $0xfe85 // testl %edi, %esi + LONG $0x0829850f; WORD $0x0000 // jne LBB28_255, $2089(%rip) + WORD $0xc90f // bswapl %ecx + WORD $0xce89 // movl %ecx, %esi + WORD $0xeec1; BYTE $0x04 // shrl $4, %esi + WORD $0xd6f7 // notl %esi + LONG $0x0101e681; WORD $0x0101 // andl $16843009, %esi + WORD $0x348d; BYTE $0xf6 // leal (%rsi,%rsi,8), %esi + LONG $0x0f0fe181; WORD $0x0f0f // andl $252645135, %ecx + WORD $0xf101 // addl %esi, %ecx + WORD $0x8941; BYTE $0xcf // movl %ecx, %r15d + LONG $0x04efc141 // shrl $4, %r15d + WORD $0x0941; BYTE $0xcf // orl %ecx, %r15d + WORD $0x8944; BYTE $0xfe // movl %r15d, %esi + WORD $0xeec1; BYTE $0x08 // shrl $8, %esi + LONG $0xff00e681; WORD $0x0000 // andl $65280, %esi + LONG $0xcfb60f41 // movzbl %r15b, %ecx + WORD $0xf109 // orl %esi, %ecx + LONG $0x06538d4c // leaq $6(%rbx), %r10 + WORD $0xf983; BYTE $0x7f // cmpl $127, %ecx + LONG $0x00ae860f; WORD $0x0000 // jbe LBB28_116, $174(%rip) + LONG $0x07fff981; WORD $0x0000 // cmpl $2047, %ecx + LONG $0x00b0860f; WORD $0x0000 // jbe LBB28_117, $176(%rip) + WORD $0x8944; BYTE $0xff // movl %r15d, %edi + LONG $0x0000e781; WORD $0x00f8 // andl $16252928, %edi + LONG $0x0000ff81; WORD $0x00d8 // cmpl $14155776, %edi + LONG $0x00bd840f; WORD $0x0000 // je LBB28_118, $189(%rip) + WORD $0xeec1; BYTE $0x0c // shrl $12, %esi + LONG $0xe0ce8040 // orb $-32, %sil + LONG $0xd0758840 // movb %sil, $-48(%rbp) + WORD $0xe9c1; BYTE $0x06 // shrl $6, %ecx + WORD $0xe180; BYTE $0x3f // andb $63, %cl + WORD $0xc980; BYTE $0x80 // orb $-128, %cl + WORD $0x4d88; BYTE $0xd1 // movb %cl, $-47(%rbp) + LONG $0x3fe78041 // andb $63, %r15b + LONG $0x80cf8041 // orb $-128, %r15b + LONG $0xd27d8844 // movb %r15b, $-46(%rbp) + LONG $0x000003ba; BYTE $0x00 // movl $3, %edx + WORD $0x8941; BYTE $0xf7 // movl %esi, %r15d -LBB33_27: - QUAD $0x00000000b845c748 // movq $0, $-72(%rbp) - WORD $0x8b49; BYTE $0x0e // movq (%r14), %rcx - WORD $0x0149; BYTE $0xcc // addq %rcx, %r12 - LONG $0xc065894c // movq %r12, $-64(%rbp) - LONG $0x01348d48 // leaq (%rcx,%rax), %rsi - WORD $0xff48; BYTE $0xce // decq %rsi - LONG $0x2f3c8d4b // leaq (%r15,%r13), %rdi - WORD $0x3949; BYTE $0xf4 // cmpq %rsi, %r12 - LONG $0x00c9830f; WORD $0x0000 // jae LBB33_44, $201(%rip) - WORD $0x854d; BYTE $0xff // testq %r15, %r15 - LONG $0x00c08e0f; WORD $0x0000 // jle LBB33_44, $192(%rip) - LONG $0xb8558d48 // leaq $-72(%rbp), %rdx - LONG $0xa8758948 // movq %rsi, $-88(%rbp) +LBB28_102: + WORD $0x894c; BYTE $0xd3 // movq %r10, %rbx + LONG $0x15548d4c; BYTE $0xd0 // leaq $-48(%rbp,%rdx), %r10 + WORD $0x394d; BYTE $0xde // cmpq %r11, %r14 + LONG $0x01bb830f; WORD $0x0000 // jae LBB28_112, $443(%rip) -LBB33_30: - LONG $0x04b60f41; BYTE $0x24 // movzbl (%r12), %eax - WORD $0x5c3c // cmpb $92, %al - LONG $0x0069850f; WORD $0x0000 // jne LBB33_37, $105(%rip) - WORD $0x8948; BYTE $0xfb // movq %rdi, %rbx - LONG $0xc07d8d48 // leaq $-64(%rbp), %rdi - WORD $0x8949; BYTE $0xd7 // movq %rdx, %r15 - LONG $0x001e13e8; BYTE $0x00 // callq _unescape, $7699(%rip) - WORD $0x8548; BYTE $0xc0 // testq %rax, %rax - LONG $0x0168880f; WORD $0x0000 // js LBB33_57, $360(%rip) - LONG $0x280c8d48 // leaq (%rax,%rbp), %rcx - LONG $0xb8c18348 // addq $-72, %rcx - WORD $0x8948; BYTE $0xdf // movq %rbx, %rdi - WORD $0x3949; BYTE $0xdd // cmpq %rbx, %r13 - LONG $0xc8658b4c // movq $-56(%rbp), %r12 - LONG $0x0052830f; WORD $0x0000 // jae LBB33_39, $82(%rip) - WORD $0x8548; BYTE $0xc0 // testq %rax, %rax - WORD $0x894c; BYTE $0xfa // movq %r15, %rdx - WORD $0x894c; BYTE $0xf8 // movq %r15, %rax - LONG $0x0049840f; WORD $0x0000 // je LBB33_40, $73(%rip) +LBB28_104: + LONG $0xd04d8d48 // leaq $-48(%rbp), %rcx + WORD $0x3949; BYTE $0xca // cmpq %rcx, %r10 + LONG $0x01ae860f; WORD $0x0000 // jbe LBB28_112, $430(%rip) + WORD $0x3845; BYTE $0x3e // cmpb %r15b, (%r14) + LONG $0x01a5850f; WORD $0x0000 // jne LBB28_112, $421(%rip) + WORD $0xff49; BYTE $0xc6 // incq %r14 + LONG $0xd1758d48 // leaq $-47(%rbp), %rsi + WORD $0x894c; BYTE $0xf7 // movq %r14, %rdi -LBB33_34: - LONG $0x5db60f41; BYTE $0x00 // movzbl (%r13), %ebx - WORD $0x183a // cmpb (%rax), %bl - LONG $0x003c850f; WORD $0x0000 // jne LBB33_40, $60(%rip) - WORD $0xff49; BYTE $0xc5 // incq %r13 - WORD $0xff48; BYTE $0xc0 // incq %rax - WORD $0x3949; BYTE $0xfd // cmpq %rdi, %r13 - LONG $0x002d830f; WORD $0x0000 // jae LBB33_40, $45(%rip) - WORD $0x3948; BYTE $0xc8 // cmpq %rcx, %rax - LONG $0xffdb820f; WORD $0xffff // jb LBB33_34, $-37(%rip) - LONG $0x00001fe9; BYTE $0x00 // jmp LBB33_40, $31(%rip) +LBB28_107: + WORD $0x8949; BYTE $0xfe // movq %rdi, %r14 + WORD $0x8948; BYTE $0xf2 // movq %rsi, %rdx + WORD $0x394c; BYTE $0xd6 // cmpq %r10, %rsi + LONG $0x0190830f; WORD $0x0000 // jae LBB28_113, $400(%rip) + WORD $0x394d; BYTE $0xde // cmpq %r11, %r14 + LONG $0x0187830f; WORD $0x0000 // jae LBB28_113, $391(%rip) + LONG $0x0eb60f41 // movzbl (%r14), %ecx + LONG $0x017e8d49 // leaq $1(%r14), %rdi + LONG $0x01728d48 // leaq $1(%rdx), %rsi + WORD $0x0a3a // cmpb (%rdx), %cl + LONG $0xffd4840f; WORD $0xffff // je LBB28_107, $-44(%rip) + LONG $0x00016ee9; BYTE $0x00 // jmp LBB28_113, $366(%rip) + +LBB28_116: + LONG $0xd07d8844 // movb %r15b, $-48(%rbp) + LONG $0x000001ba; BYTE $0x00 // movl $1, %edx + LONG $0xffff90e9; BYTE $0xff // jmp LBB28_102, $-112(%rip) + +LBB28_117: + WORD $0xe9c1; BYTE $0x06 // shrl $6, %ecx + WORD $0xc980; BYTE $0xc0 // orb $-64, %cl + WORD $0x4d88; BYTE $0xd0 // movb %cl, $-48(%rbp) + LONG $0x3fe78041 // andb $63, %r15b + LONG $0x80cf8041 // orb $-128, %r15b + LONG $0xd17d8844 // movb %r15b, $-47(%rbp) + LONG $0x000002ba; BYTE $0x00 // movl $2, %edx + WORD $0x8941; BYTE $0xcf // movl %ecx, %r15d + LONG $0xffff6ee9; BYTE $0xff // jmp LBB28_102, $-146(%rip) + +LBB28_118: + LONG $0x06fa8348 // cmpq $6, %rdx + LONG $0x07388c0f; WORD $0x0000 // jl LBB28_260, $1848(%rip) + LONG $0xdbfff981; WORD $0x0000 // cmpl $56319, %ecx + LONG $0x072c870f; WORD $0x0000 // ja LBB28_260, $1836(%rip) + LONG $0x5c3a8041 // cmpb $92, (%r10) + LONG $0x0722850f; WORD $0x0000 // jne LBB28_260, $1826(%rip) + LONG $0x75077b80 // cmpb $117, $7(%rbx) + LONG $0x0718850f; WORD $0x0000 // jne LBB28_260, $1816(%rip) + LONG $0x08538d4c // leaq $8(%rbx), %r10 + WORD $0x538b; BYTE $0x08 // movl $8(%rbx), %edx + WORD $0xd789 // movl %edx, %edi + WORD $0xd7f7 // notl %edi + LONG $0xcfd0b28d; WORD $0xcfcf // leal $-808464432(%rdx), %esi + LONG $0x8080e781; WORD $0x8080 // andl $-2139062144, %edi + WORD $0xf785 // testl %esi, %edi + LONG $0x06ed850f; WORD $0x0000 // jne LBB28_259, $1773(%rip) + LONG $0x1919b28d; WORD $0x1919 // leal $421075225(%rdx), %esi + WORD $0xd609 // orl %edx, %esi + LONG $0x8080c6f7; WORD $0x8080 // testl $-2139062144, %esi + LONG $0x06d9850f; WORD $0x0000 // jne LBB28_259, $1753(%rip) + WORD $0xd689 // movl %edx, %esi + LONG $0x7f7fe681; WORD $0x7f7f // andl $2139062143, %esi + LONG $0xc0c0bf41; WORD $0xc0c0 // movl $-1061109568, %r15d + WORD $0x2941; BYTE $0xf7 // subl %esi, %r15d + LONG $0x46ae8d44; WORD $0x4646; BYTE $0x46 // leal $1179010630(%rsi), %r13d + WORD $0x2141; BYTE $0xff // andl %edi, %r15d + WORD $0x8545; BYTE $0xef // testl %r13d, %r15d + LONG $0x06b5850f; WORD $0x0000 // jne LBB28_259, $1717(%rip) + LONG $0xe0e0bf41; WORD $0xe0e0 // movl $-522133280, %r15d + WORD $0x2941; BYTE $0xf7 // subl %esi, %r15d + LONG $0x3939c681; WORD $0x3939 // addl $960051513, %esi + WORD $0x2144; BYTE $0xff // andl %r15d, %edi + WORD $0xf785 // testl %esi, %edi + LONG $0x069b850f; WORD $0x0000 // jne LBB28_259, $1691(%rip) + WORD $0xca0f // bswapl %edx + WORD $0xd689 // movl %edx, %esi + WORD $0xeec1; BYTE $0x04 // shrl $4, %esi + WORD $0xd6f7 // notl %esi + LONG $0x0101e681; WORD $0x0101 // andl $16843009, %esi + WORD $0x348d; BYTE $0xf6 // leal (%rsi,%rsi,8), %esi + LONG $0x0f0fe281; WORD $0x0f0f // andl $252645135, %edx + WORD $0xf201 // addl %esi, %edx + WORD $0xd689 // movl %edx, %esi + WORD $0xeec1; BYTE $0x04 // shrl $4, %esi + WORD $0xd609 // orl %edx, %esi + WORD $0xf289 // movl %esi, %edx + LONG $0x0000e281; WORD $0x00fc // andl $16515072, %edx + LONG $0x0000fa81; WORD $0x00dc // cmpl $14417920, %edx + LONG $0x0672850f; WORD $0x0000 // jne LBB28_260, $1650(%rip) + WORD $0xf289 // movl %esi, %edx + WORD $0xeac1; BYTE $0x08 // shrl $8, %edx + LONG $0xff00e281; WORD $0x0000 // andl $65280, %edx + LONG $0xf6b60f40 // movzbl %sil, %esi + WORD $0xd609 // orl %edx, %esi + WORD $0xe1c1; BYTE $0x0a // shll $10, %ecx + LONG $0x00318c8d; WORD $0xa024; BYTE $0xfc // leal $-56613888(%rcx,%rsi), %ecx + WORD $0x8941; BYTE $0xcf // movl %ecx, %r15d + LONG $0x12efc141 // shrl $18, %r15d + LONG $0xf0cf8041 // orb $-16, %r15b + LONG $0xd07d8844 // movb %r15b, $-48(%rbp) + WORD $0xca89 // movl %ecx, %edx + WORD $0xeac1; BYTE $0x0c // shrl $12, %edx + WORD $0xe280; BYTE $0x3f // andb $63, %dl + WORD $0xca80; BYTE $0x80 // orb $-128, %dl + WORD $0x5588; BYTE $0xd1 // movb %dl, $-47(%rbp) + WORD $0xca89 // movl %ecx, %edx + WORD $0xeac1; BYTE $0x06 // shrl $6, %edx + WORD $0xe280; BYTE $0x3f // andb $63, %dl + WORD $0xca80; BYTE $0x80 // orb $-128, %dl + WORD $0x5588; BYTE $0xd2 // movb %dl, $-46(%rbp) + WORD $0xe180; BYTE $0x3f // andb $63, %cl + WORD $0xc980; BYTE $0x80 // orb $-128, %cl + WORD $0x4d88; BYTE $0xd3 // movb %cl, $-45(%rbp) + LONG $0x0cc38348 // addq $12, %rbx + LONG $0x000004ba; BYTE $0x00 // movl $4, %edx + LONG $0xc86d8b4c // movq $-56(%rbp), %r13 + LONG $0x15548d4c; BYTE $0xd0 // leaq $-48(%rbp,%rdx), %r10 + WORD $0x394d; BYTE $0xde // cmpq %r11, %r14 + LONG $0xfe45820f; WORD $0xffff // jb LBB28_104, $-443(%rip) -LBB33_37: - LONG $0x00453a41 // cmpb (%r13), %al - LONG $0xfe42850f; WORD $0xffff // jne LBB33_12, $-446(%rip) - WORD $0xff49; BYTE $0xc4 // incq %r12 - LONG $0xc065894c // movq %r12, $-64(%rbp) - WORD $0xff49; BYTE $0xc5 // incq %r13 - LONG $0x000017e9; BYTE $0x00 // jmp LBB33_42, $23(%rip) +LBB28_112: + LONG $0xd0558d48 // leaq $-48(%rbp), %rdx -LBB33_39: - WORD $0x894c; BYTE $0xfa // movq %r15, %rdx - WORD $0x894c; BYTE $0xf8 // movq %r15, %rax +LBB28_113: + WORD $0x394c; BYTE $0xd2 // cmpq %r10, %rdx + LONG $0x02dc850f; WORD $0x0000 // jne LBB28_182, $732(%rip) -LBB33_40: - WORD $0x3948; BYTE $0xc8 // cmpq %rcx, %rax - LONG $0x002d850f; WORD $0x0000 // jne LBB33_26, $45(%rip) - LONG $0xc0658b4c // movq $-64(%rbp), %r12 - LONG $0xa8758b48 // movq $-88(%rbp), %rsi - -LBB33_42: - WORD $0x3949; BYTE $0xf4 // cmpq %rsi, %r12 - LONG $0x0009830f; WORD $0x0000 // jae LBB33_44, $9(%rip) - WORD $0x3949; BYTE $0xfd // cmpq %rdi, %r13 - LONG $0xff48820f; WORD $0xffff // jb LBB33_30, $-184(%rip) - -LBB33_44: - WORD $0x3149; BYTE $0xf4 // xorq %rsi, %r12 - WORD $0x3149; BYTE $0xfd // xorq %rdi, %r13 - WORD $0xdb31 // xorl %ebx, %ebx - WORD $0x094d; BYTE $0xe5 // orq %r12, %r13 - WORD $0x940f; BYTE $0xc3 // sete %bl - LONG $0xfffdf9e9; BYTE $0xff // jmp LBB33_13, $-519(%rip) +LBB28_114: + WORD $0x3949; BYTE $0xd8 // cmpq %rbx, %r8 + LONG $0x0012860f; WORD $0x0000 // jbe LBB28_129, $18(%rip) + WORD $0x394d; BYTE $0xde // cmpq %r11, %r14 + LONG $0xfc98820f; WORD $0xffff // jb LBB28_86, $-872(%rip) + LONG $0x000004e9; BYTE $0x00 // jmp LBB28_129, $4(%rip) + +LBB28_128: + LONG $0xc86d8b4c // movq $-56(%rbp), %r13 + +LBB28_129: + WORD $0x3149; BYTE $0xd8 // xorq %rbx, %r8 + WORD $0x314d; BYTE $0xde // xorq %r11, %r14 + WORD $0x3145; BYTE $0xd2 // xorl %r10d, %r10d + WORD $0x094d; BYTE $0xc6 // orq %r8, %r14 + LONG $0xc2940f41 // sete %r10b + +LBB28_130: + LONG $0xc05d8b4c // movq $-64(%rbp), %r11 + LONG $0x08738b49 // movq $8(%r11), %rsi + WORD $0x8948; BYTE $0xc7 // movq %rax, %rdi + WORD $0x2948; BYTE $0xf7 // subq %rsi, %rdi + LONG $0xfc10820f; WORD $0xffff // jb LBB28_80, $-1008(%rip) + LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 + +LBB28_131: + LONG $0x01588d48 // leaq $1(%rax), %rbx + WORD $0x3948; BYTE $0xf3 // cmpq %rsi, %rbx + LONG $0x0023830f; WORD $0x0000 // jae LBB28_135, $35(%rip) + LONG $0x19148a41 // movb (%r9,%rbx), %dl + WORD $0xfa80; BYTE $0x0d // cmpb $13, %dl + LONG $0x0016840f; WORD $0x0000 // je LBB28_135, $22(%rip) + WORD $0xfa80; BYTE $0x20 // cmpb $32, %dl + LONG $0x000d840f; WORD $0x0000 // je LBB28_135, $13(%rip) + WORD $0xc280; BYTE $0xf7 // addb $-9, %dl + WORD $0xfa80; BYTE $0x01 // cmpb $1, %dl + LONG $0x00f3870f; WORD $0x0000 // ja LBB28_152, $243(%rip) + BYTE $0x90 // .p2align 4, 0x90 -LBB33_26: - WORD $0xdb31 // xorl %ebx, %ebx - LONG $0xfffdf6e9; BYTE $0xff // jmp LBB33_14, $-522(%rip) +LBB28_135: + LONG $0x02588d48 // leaq $2(%rax), %rbx + WORD $0x3948; BYTE $0xf3 // cmpq %rsi, %rbx + LONG $0x0023830f; WORD $0x0000 // jae LBB28_139, $35(%rip) + LONG $0x19148a41 // movb (%r9,%rbx), %dl + WORD $0xfa80; BYTE $0x0d // cmpb $13, %dl + LONG $0x0016840f; WORD $0x0000 // je LBB28_139, $22(%rip) + WORD $0xfa80; BYTE $0x20 // cmpb $32, %dl + LONG $0x000d840f; WORD $0x0000 // je LBB28_139, $13(%rip) + WORD $0xc280; BYTE $0xf7 // addb $-9, %dl + WORD $0xfa80; BYTE $0x01 // cmpb $1, %dl + LONG $0x00c3870f; WORD $0x0000 // ja LBB28_152, $195(%rip) + BYTE $0x90 // .p2align 4, 0x90 + +LBB28_139: + LONG $0x03588d48 // leaq $3(%rax), %rbx + WORD $0x3948; BYTE $0xf3 // cmpq %rsi, %rbx + LONG $0x0023830f; WORD $0x0000 // jae LBB28_143, $35(%rip) + LONG $0x19148a41 // movb (%r9,%rbx), %dl + WORD $0xfa80; BYTE $0x0d // cmpb $13, %dl + LONG $0x0016840f; WORD $0x0000 // je LBB28_143, $22(%rip) + WORD $0xfa80; BYTE $0x20 // cmpb $32, %dl + LONG $0x000d840f; WORD $0x0000 // je LBB28_143, $13(%rip) + WORD $0xc280; BYTE $0xf7 // addb $-9, %dl + WORD $0xfa80; BYTE $0x01 // cmpb $1, %dl + LONG $0x0093870f; WORD $0x0000 // ja LBB28_152, $147(%rip) + BYTE $0x90 // .p2align 4, 0x90 + +LBB28_143: + LONG $0x04508d48 // leaq $4(%rax), %rdx + WORD $0x3948; BYTE $0xd6 // cmpq %rdx, %rsi + LONG $0x045b860f; WORD $0x0000 // jbe LBB28_244, $1115(%rip) + WORD $0x3948; BYTE $0xd6 // cmpq %rdx, %rsi + LONG $0x004a840f; WORD $0x0000 // je LBB28_149, $74(%rip) + LONG $0x31148d49 // leaq (%r9,%rsi), %rdx + LONG $0x04c78348 // addq $4, %rdi + LONG $0x015c8d49; BYTE $0x05 // leaq $5(%r9,%rax), %rbx QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 -LBB33_47: - WORD $0xf980; BYTE $0x02 // cmpb $2, %cl - LONG $0x0078850f; WORD $0x0000 // jne LBB33_54, $120(%rip) - WORD $0x5b3c // cmpb $91, %al - LONG $0x0070850f; WORD $0x0000 // jne LBB33_54, $112(%rip) - LONG $0x08478b49 // movq $8(%r15), %rax - WORD $0x8b48; BYTE $0x18 // movq (%rax), %rbx +LBB28_146: + LONG $0xff4bbe0f // movsbl $-1(%rbx), %ecx + WORD $0xf983; BYTE $0x20 // cmpl $32, %ecx + LONG $0x0043870f; WORD $0x0000 // ja LBB28_151, $67(%rip) + LONG $0xcca30f49 // btq %rcx, %r12 + LONG $0x0039830f; WORD $0x0000 // jae LBB28_151, $57(%rip) WORD $0xff48; BYTE $0xc3 // incq %rbx - LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 + WORD $0xff48; BYTE $0xc7 // incq %rdi + LONG $0xffdd850f; WORD $0xffff // jne LBB28_146, $-35(%rip) + LONG $0x00000be9; BYTE $0x00 // jmp LBB28_150, $11(%rip) + QUAD $0x9090909090909090 // .p2align 4, 0x90 + +LBB28_149: + WORD $0x014c; BYTE $0xca // addq %r9, %rdx + +LBB28_150: + WORD $0x294c; BYTE $0xca // subq %r9, %rdx + WORD $0x8948; BYTE $0xd3 // movq %rdx, %rbx + WORD $0x3948; BYTE $0xf3 // cmpq %rsi, %rbx + LONG $0x0020820f; WORD $0x0000 // jb LBB28_152, $32(%rip) + LONG $0x0003f8e9; BYTE $0x00 // jmp LBB28_246, $1016(%rip) + QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90 -LBB33_50: - WORD $0xff48; BYTE $0xcb // decq %rbx - WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx - LONG $0x00348e0f; WORD $0x0000 // jle LBB33_52, $52(%rip) - WORD $0x894c; BYTE $0xf7 // movq %r14, %rdi - WORD $0x894c; BYTE $0xe6 // movq %r12, %rsi - LONG $0xfff069e8; BYTE $0xff // callq _skip_one_fast, $-3991(%rip) - WORD $0x8b49; BYTE $0x3e // movq (%r14), %rdi - LONG $0x08768b49 // movq $8(%r14), %rsi - WORD $0x894c; BYTE $0xe2 // movq %r12, %rdx - LONG $0xffd0cae8; BYTE $0xff // callq _advance_ns, $-12086(%rip) - WORD $0x2c3c // cmpb $44, %al - LONG $0xffd2840f; WORD $0xffff // je LBB33_50, $-46(%rip) - LONG $0x00002ee9; BYTE $0x00 // jmp LBB33_54, $46(%rip) +LBB28_151: + WORD $0x894c; BYTE $0xc9 // movq %r9, %rcx + WORD $0xf748; BYTE $0xd1 // notq %rcx + WORD $0x0148; BYTE $0xcb // addq %rcx, %rbx + WORD $0x3948; BYTE $0xf3 // cmpq %rsi, %rbx + LONG $0x03dd830f; WORD $0x0000 // jae LBB28_246, $989(%rip) + +LBB28_152: + LONG $0x01538d48 // leaq $1(%rbx), %rdx + LONG $0x00558949 // movq %rdx, (%r13) + LONG $0x193c8041; BYTE $0x3a // cmpb $58, (%r9,%rbx) + LONG $0x03c7850f; WORD $0x0000 // jne LBB28_245, $967(%rip) + WORD $0x854d; BYTE $0xd2 // testq %r10, %r10 + LONG $0x0379850f; WORD $0x0000 // jne LBB28_242, $889(%rip) + WORD $0x894c; BYTE $0xdf // movq %r11, %rdi + WORD $0x894c; BYTE $0xee // movq %r13, %rsi + LONG $0xffe6a7e8; BYTE $0xff // callq _skip_one_fast, $-6489(%rip) + LONG $0xc05d8b4c // movq $-64(%rbp), %r11 + WORD $0x8b4d; BYTE $0x0b // movq (%r11), %r9 + LONG $0x084b8b49 // movq $8(%r11), %rcx + LONG $0x00458b49 // movq (%r13), %rax + WORD $0x8948; BYTE $0xc6 // movq %rax, %rsi + WORD $0x2948; BYTE $0xce // subq %rcx, %rsi + LONG $0x002c830f; WORD $0x0000 // jae LBB28_159, $44(%rip) + LONG $0x01148a41 // movb (%r9,%rax), %dl + WORD $0xfa80; BYTE $0x0d // cmpb $13, %dl + LONG $0x001f840f; WORD $0x0000 // je LBB28_159, $31(%rip) + WORD $0xfa80; BYTE $0x20 // cmpb $32, %dl + LONG $0x0016840f; WORD $0x0000 // je LBB28_159, $22(%rip) + WORD $0xc280; BYTE $0xf7 // addb $-9, %dl + WORD $0xfa80; BYTE $0x01 // cmpb $1, %dl + LONG $0x000a860f; WORD $0x0000 // jbe LBB28_159, $10(%rip) + WORD $0x8948; BYTE $0xc7 // movq %rax, %rdi + LONG $0xfff79ce9; BYTE $0xff // jmp LBB28_180, $-2148(%rip) + WORD $0x9090 // .p2align 4, 0x90 + +LBB28_159: + LONG $0x01788d48 // leaq $1(%rax), %rdi + WORD $0x3948; BYTE $0xcf // cmpq %rcx, %rdi + LONG $0x0023830f; WORD $0x0000 // jae LBB28_163, $35(%rip) + LONG $0x39148a41 // movb (%r9,%rdi), %dl + WORD $0xfa80; BYTE $0x0d // cmpb $13, %dl + LONG $0x0016840f; WORD $0x0000 // je LBB28_163, $22(%rip) + WORD $0xfa80; BYTE $0x20 // cmpb $32, %dl + LONG $0x000d840f; WORD $0x0000 // je LBB28_163, $13(%rip) + WORD $0xc280; BYTE $0xf7 // addb $-9, %dl + WORD $0xfa80; BYTE $0x01 // cmpb $1, %dl + LONG $0xf76b870f; WORD $0xffff // ja LBB28_180, $-2197(%rip) + BYTE $0x90 // .p2align 4, 0x90 + +LBB28_163: + LONG $0x02788d48 // leaq $2(%rax), %rdi + WORD $0x3948; BYTE $0xcf // cmpq %rcx, %rdi + LONG $0x0023830f; WORD $0x0000 // jae LBB28_167, $35(%rip) + LONG $0x39148a41 // movb (%r9,%rdi), %dl + WORD $0xfa80; BYTE $0x0d // cmpb $13, %dl + LONG $0x0016840f; WORD $0x0000 // je LBB28_167, $22(%rip) + WORD $0xfa80; BYTE $0x20 // cmpb $32, %dl + LONG $0x000d840f; WORD $0x0000 // je LBB28_167, $13(%rip) + WORD $0xc280; BYTE $0xf7 // addb $-9, %dl + WORD $0xfa80; BYTE $0x01 // cmpb $1, %dl + LONG $0xf73b870f; WORD $0xffff // ja LBB28_180, $-2245(%rip) + BYTE $0x90 // .p2align 4, 0x90 + +LBB28_167: + LONG $0x03788d48 // leaq $3(%rax), %rdi + WORD $0x3948; BYTE $0xcf // cmpq %rcx, %rdi + LONG $0x0023830f; WORD $0x0000 // jae LBB28_171, $35(%rip) + LONG $0x39148a41 // movb (%r9,%rdi), %dl + WORD $0xfa80; BYTE $0x0d // cmpb $13, %dl + LONG $0x0016840f; WORD $0x0000 // je LBB28_171, $22(%rip) + WORD $0xfa80; BYTE $0x20 // cmpb $32, %dl + LONG $0x000d840f; WORD $0x0000 // je LBB28_171, $13(%rip) + WORD $0xc280; BYTE $0xf7 // addb $-9, %dl + WORD $0xfa80; BYTE $0x01 // cmpb $1, %dl + LONG $0xf70b870f; WORD $0xffff // ja LBB28_180, $-2293(%rip) + BYTE $0x90 // .p2align 4, 0x90 + +LBB28_171: + LONG $0x04508d48 // leaq $4(%rax), %rdx + WORD $0x3948; BYTE $0xd1 // cmpq %rdx, %rcx + LONG $0x02cb860f; WORD $0x0000 // jbe LBB28_244, $715(%rip) + WORD $0x3948; BYTE $0xd1 // cmpq %rdx, %rcx + LONG $0x004a840f; WORD $0x0000 // je LBB28_177, $74(%rip) + LONG $0x09148d49 // leaq (%r9,%rcx), %rdx + LONG $0x04c68348 // addq $4, %rsi + LONG $0x017c8d49; BYTE $0x05 // leaq $5(%r9,%rax), %rdi QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 -LBB33_52: - LONG $0x10c78349 // addq $16, %r15 - LONG $0xa0458b48 // movq $-96(%rbp), %rax - WORD $0x3949; BYTE $0xc7 // cmpq %rax, %r15 - LONG $0xfc81850f; WORD $0xffff // jne LBB33_2, $-895(%rip) - -LBB33_53: - WORD $0x894c; BYTE $0xf7 // movq %r14, %rdi - WORD $0x894c; BYTE $0xe6 // movq %r12, %rsi - LONG $0xfff024e8; BYTE $0xff // callq _skip_one_fast, $-4060(%rip) - LONG $0x00000be9; BYTE $0x00 // jmp LBB33_55, $11(%rip) - -LBB33_54: - LONG $0x240cff49 // decq (%r12) - LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq $-2, %rax +LBB28_174: + LONG $0xff5fbe0f // movsbl $-1(%rdi), %ebx + WORD $0xfb83; BYTE $0x20 // cmpl $32, %ebx + LONG $0xf6bb870f; WORD $0xffff // ja LBB28_179, $-2373(%rip) + LONG $0xdca30f49 // btq %rbx, %r12 + LONG $0xf6b1830f; WORD $0xffff // jae LBB28_179, $-2383(%rip) + WORD $0xff48; BYTE $0xc7 // incq %rdi + WORD $0xff48; BYTE $0xc6 // incq %rsi + LONG $0xffdd850f; WORD $0xffff // jne LBB28_174, $-35(%rip) + LONG $0x00000be9; BYTE $0x00 // jmp LBB28_178, $11(%rip) + QUAD $0x9090909090909090 // .p2align 4, 0x90 -LBB33_55: - LONG $0x38c48348 // addq $56, %rsp - BYTE $0x5b // popq %rbx - WORD $0x5c41 // popq %r12 - WORD $0x5d41 // popq %r13 - WORD $0x5e41 // popq %r14 - WORD $0x5f41 // popq %r15 - BYTE $0x5d // popq %rbp - BYTE $0xc3 // retq +LBB28_177: + WORD $0x014c; BYTE $0xca // addq %r9, %rdx -LBB33_56: - LONG $0x08468b49 // movq $8(%r14), %rax - WORD $0x8948; BYTE $0x03 // movq %rax, (%rbx) - LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax - LONG $0xffffdee9; BYTE $0xff // jmp LBB33_55, $-34(%rip) - -LBB33_57: - LONG $0xc04d8b48 // movq $-64(%rbp), %rcx - WORD $0x2b49; BYTE $0x0e // subq (%r14), %rcx - LONG $0xc8558b48 // movq $-56(%rbp), %rdx - WORD $0x8948; BYTE $0x0a // movq %rcx, (%rdx) - LONG $0xffffcbe9; BYTE $0xff // jmp LBB33_55, $-53(%rip) +LBB28_178: + WORD $0x294c; BYTE $0xca // subq %r9, %rdx + WORD $0x8948; BYTE $0xd7 // movq %rdx, %rdi + WORD $0x3948; BYTE $0xcf // cmpq %rcx, %rdi + LONG $0xf698820f; WORD $0xffff // jb LBB28_180, $-2408(%rip) + LONG $0x000268e9; BYTE $0x00 // jmp LBB28_246, $616(%rip) + +LBB28_182: + WORD $0x3145; BYTE $0xd2 // xorl %r10d, %r10d + LONG $0xfffd47e9; BYTE $0xff // jmp LBB28_130, $-697(%rip) + +LBB28_208: + LONG $0x00558949 // movq %rdx, (%r13) + WORD $0x8948; BYTE $0xd0 // movq %rdx, %rax + LONG $0x000053e9; BYTE $0x00 // jmp LBB28_213, $83(%rip) + +LBB28_29: + WORD $0x894c; BYTE $0xc8 // movq %r9, %rax + WORD $0xf748; BYTE $0xd0 // notq %rax + WORD $0x0148; BYTE $0xc6 // addq %rax, %rsi + WORD $0x394c; BYTE $0xc6 // cmpq %r8, %rsi + LONG $0xf465820f; WORD $0xffff // jb LBB28_28, $-2971(%rip) + LONG $0xfff4bbe9; BYTE $0xff // jmp LBB28_30, $-2885(%rip) + +LBB28_209: + WORD $0x014c; BYTE $0xca // addq %r9, %rdx + +LBB28_210: + WORD $0x294c; BYTE $0xca // subq %r9, %rdx + WORD $0x8948; BYTE $0xd7 // movq %rdx, %rdi + WORD $0x394c; BYTE $0xc7 // cmpq %r8, %rdi + LONG $0x0017820f; WORD $0x0000 // jb LBB28_212, $23(%rip) + LONG $0x000025e9; BYTE $0x00 // jmp LBB28_213, $37(%rip) + +LBB28_211: + WORD $0x894c; BYTE $0xc9 // movq %r9, %rcx + WORD $0xf748; BYTE $0xd1 // notq %rcx + WORD $0x0148; BYTE $0xcf // addq %rcx, %rdi + WORD $0x394c; BYTE $0xc7 // cmpq %r8, %rdi + LONG $0x0013830f; WORD $0x0000 // jae LBB28_213, $19(%rip) + +LBB28_212: + LONG $0x01478d48 // leaq $1(%rdi), %rax + LONG $0x00458949 // movq %rax, (%r13) + LONG $0x393c8041; BYTE $0x5d // cmpb $93, (%r9,%rdi) + LONG $0x0250840f; WORD $0x0000 // je LBB28_253, $592(%rip) + +LBB28_213: + WORD $0xff48; BYTE $0xc8 // decq %rax + LONG $0x00458949 // movq %rax, (%r13) + WORD $0x8948; BYTE $0xc2 // movq %rax, %rdx + WORD $0x854d; BYTE $0xf6 // testq %r14, %r14 + LONG $0x01a68e0f; WORD $0x0000 // jle LBB28_242, $422(%rip) QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 +LBB28_214: + WORD $0x894c; BYTE $0xdf // movq %r11, %rdi + WORD $0x894c; BYTE $0xee // movq %r13, %rsi + LONG $0xffe4c5e8; BYTE $0xff // callq _skip_one_fast, $-6971(%rip) + LONG $0xc05d8b4c // movq $-64(%rbp), %r11 + WORD $0x8b4d; BYTE $0x0b // movq (%r11), %r9 + LONG $0x084b8b49 // movq $8(%r11), %rcx + LONG $0x00458b49 // movq (%r13), %rax + WORD $0x8948; BYTE $0xc6 // movq %rax, %rsi + WORD $0x2948; BYTE $0xce // subq %rcx, %rsi + LONG $0x002a830f; WORD $0x0000 // jae LBB28_219, $42(%rip) + LONG $0x01148a41 // movb (%r9,%rax), %dl + WORD $0xfa80; BYTE $0x0d // cmpb $13, %dl + LONG $0x001d840f; WORD $0x0000 // je LBB28_219, $29(%rip) + WORD $0xfa80; BYTE $0x20 // cmpb $32, %dl + LONG $0x0014840f; WORD $0x0000 // je LBB28_219, $20(%rip) + WORD $0xc280; BYTE $0xf7 // addb $-9, %dl + WORD $0xfa80; BYTE $0x01 // cmpb $1, %dl + LONG $0x0008860f; WORD $0x0000 // jbe LBB28_219, $8(%rip) + WORD $0x8948; BYTE $0xc7 // movq %rax, %rdi + LONG $0x000122e9; BYTE $0x00 // jmp LBB28_240, $290(%rip) + + // .p2align 4, 0x90 +LBB28_219: + LONG $0x01788d48 // leaq $1(%rax), %rdi + WORD $0x3948; BYTE $0xcf // cmpq %rcx, %rdi + LONG $0x0023830f; WORD $0x0000 // jae LBB28_223, $35(%rip) + LONG $0x39148a41 // movb (%r9,%rdi), %dl + WORD $0xfa80; BYTE $0x0d // cmpb $13, %dl + LONG $0x0016840f; WORD $0x0000 // je LBB28_223, $22(%rip) + WORD $0xfa80; BYTE $0x20 // cmpb $32, %dl + LONG $0x000d840f; WORD $0x0000 // je LBB28_223, $13(%rip) + WORD $0xc280; BYTE $0xf7 // addb $-9, %dl + WORD $0xfa80; BYTE $0x01 // cmpb $1, %dl + LONG $0x00f3870f; WORD $0x0000 // ja LBB28_240, $243(%rip) + BYTE $0x90 // .p2align 4, 0x90 + +LBB28_223: + LONG $0x02788d48 // leaq $2(%rax), %rdi + WORD $0x3948; BYTE $0xcf // cmpq %rcx, %rdi + LONG $0x0023830f; WORD $0x0000 // jae LBB28_227, $35(%rip) + LONG $0x39148a41 // movb (%r9,%rdi), %dl + WORD $0xfa80; BYTE $0x0d // cmpb $13, %dl + LONG $0x0016840f; WORD $0x0000 // je LBB28_227, $22(%rip) + WORD $0xfa80; BYTE $0x20 // cmpb $32, %dl + LONG $0x000d840f; WORD $0x0000 // je LBB28_227, $13(%rip) + WORD $0xc280; BYTE $0xf7 // addb $-9, %dl + WORD $0xfa80; BYTE $0x01 // cmpb $1, %dl + LONG $0x00c3870f; WORD $0x0000 // ja LBB28_240, $195(%rip) + BYTE $0x90 // .p2align 4, 0x90 + +LBB28_227: + LONG $0x03788d48 // leaq $3(%rax), %rdi + WORD $0x3948; BYTE $0xcf // cmpq %rcx, %rdi + LONG $0x0023830f; WORD $0x0000 // jae LBB28_231, $35(%rip) + LONG $0x39148a41 // movb (%r9,%rdi), %dl + WORD $0xfa80; BYTE $0x0d // cmpb $13, %dl + LONG $0x0016840f; WORD $0x0000 // je LBB28_231, $22(%rip) + WORD $0xfa80; BYTE $0x20 // cmpb $32, %dl + LONG $0x000d840f; WORD $0x0000 // je LBB28_231, $13(%rip) + WORD $0xc280; BYTE $0xf7 // addb $-9, %dl + WORD $0xfa80; BYTE $0x01 // cmpb $1, %dl + LONG $0x0093870f; WORD $0x0000 // ja LBB28_240, $147(%rip) + BYTE $0x90 // .p2align 4, 0x90 + +LBB28_231: + LONG $0x04508d48 // leaq $4(%rax), %rdx + WORD $0x3948; BYTE $0xd1 // cmpq %rdx, %rcx + LONG $0x00eb860f; WORD $0x0000 // jbe LBB28_244, $235(%rip) + WORD $0x3948; BYTE $0xd1 // cmpq %rdx, %rcx + LONG $0x004a840f; WORD $0x0000 // je LBB28_237, $74(%rip) + LONG $0x09148d49 // leaq (%r9,%rcx), %rdx + LONG $0x04c68348 // addq $4, %rsi + LONG $0x017c8d49; BYTE $0x05 // leaq $5(%r9,%rax), %rdi + QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB28_234: + LONG $0xff5fbe0f // movsbl $-1(%rdi), %ebx + WORD $0xfb83; BYTE $0x20 // cmpl $32, %ebx + LONG $0x0043870f; WORD $0x0000 // ja LBB28_239, $67(%rip) + LONG $0xdca30f49 // btq %rbx, %r12 + LONG $0x0039830f; WORD $0x0000 // jae LBB28_239, $57(%rip) + WORD $0xff48; BYTE $0xc7 // incq %rdi + WORD $0xff48; BYTE $0xc6 // incq %rsi + LONG $0xffdd850f; WORD $0xffff // jne LBB28_234, $-35(%rip) + LONG $0x00000be9; BYTE $0x00 // jmp LBB28_238, $11(%rip) + QUAD $0x9090909090909090 // .p2align 4, 0x90 + +LBB28_237: + WORD $0x014c; BYTE $0xca // addq %r9, %rdx + +LBB28_238: + WORD $0x294c; BYTE $0xca // subq %r9, %rdx + WORD $0x8948; BYTE $0xd7 // movq %rdx, %rdi + WORD $0x3948; BYTE $0xcf // cmpq %rcx, %rdi + LONG $0x0020820f; WORD $0x0000 // jb LBB28_240, $32(%rip) + LONG $0x000088e9; BYTE $0x00 // jmp LBB28_246, $136(%rip) + QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB28_239: + WORD $0x894c; BYTE $0xca // movq %r9, %rdx + WORD $0xf748; BYTE $0xd2 // notq %rdx + WORD $0x0148; BYTE $0xd7 // addq %rdx, %rdi + WORD $0x3948; BYTE $0xcf // cmpq %rcx, %rdi + LONG $0x006d830f; WORD $0x0000 // jae LBB28_246, $109(%rip) + +LBB28_240: + LONG $0x01578d48 // leaq $1(%rdi), %rdx + LONG $0x00558949 // movq %rdx, (%r13) + LONG $0x39048a41 // movb (%r9,%rdi), %al + WORD $0x2c3c // cmpb $44, %al + LONG $0x0079850f; WORD $0x0000 // jne LBB28_248, $121(%rip) + LONG $0xff468d49 // leaq $-1(%r14), %rax + LONG $0x02fe8349 // cmpq $2, %r14 + WORD $0x8949; BYTE $0xc6 // movq %rax, %r14 + LONG $0xfe698d0f; WORD $0xffff // jge LBB28_214, $-407(%rip) + +LBB28_242: + LONG $0xb8458b48 // movq $-72(%rbp), %rax + LONG $0x10c08348 // addq $16, %rax + LONG $0xa8558b4c // movq $-88(%rbp), %r10 + LONG $0xb8458948 // movq %rax, $-72(%rbp) + WORD $0x394c; BYTE $0xd0 // cmpq %r10, %rax + LONG $0xa04d8b48 // movq $-96(%rbp), %rcx + LONG $0xf11b850f; WORD $0xffff // jne LBB28_2, $-3813(%rip) + +LBB28_243: + QUAD $0xfffff0b4056ff9c5 // vmovdqa $-3916(%rip), %xmm0 /* LCPI28_0(%rip) */ + LONG $0x017ffac5 // vmovdqu %xmm0, (%rcx) + WORD $0x8948; BYTE $0xcf // movq %rcx, %rdi + WORD $0x894c; BYTE $0xde // movq %r11, %rsi + WORD $0x894c; BYTE $0xea // movq %r13, %rdx + WORD $0xc931 // xorl %ecx, %ecx + LONG $0xffd200e8; BYTE $0xff // callq _fsm_exec, $-11776(%rip) + WORD $0x8948; BYTE $0xc1 // movq %rax, %rcx + LONG $0x000015e9; BYTE $0x00 // jmp LBB28_247, $21(%rip) + +LBB28_244: + LONG $0x00558949 // movq %rdx, (%r13) + +LBB28_245: + WORD $0x8948; BYTE $0xd0 // movq %rdx, %rax + +LBB28_246: + WORD $0xff48; BYTE $0xc8 // decq %rax + LONG $0x00458949 // movq %rax, (%r13) + LONG $0xfec1c748; WORD $0xffff; BYTE $0xff // movq $-2, %rcx + +LBB28_247: + WORD $0x8948; BYTE $0xc8 // movq %rcx, %rax + LONG $0x38c48348 // addq $56, %rsp + BYTE $0x5b // popq %rbx + WORD $0x5c41 // popq %r12 + WORD $0x5d41 // popq %r13 + WORD $0x5e41 // popq %r14 + WORD $0x5f41 // popq %r15 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB28_248: + WORD $0x5d3c // cmpb $93, %al + LONG $0xffd5850f; WORD $0xffff // jne LBB28_245, $-43(%rip) + WORD $0x8948; BYTE $0xd0 // movq %rdx, %rax + LONG $0x00001fe9; BYTE $0x00 // jmp LBB28_253, $31(%rip) + +LBB28_250: + WORD $0xff48; BYTE $0xc8 // decq %rax + LONG $0x00458949 // movq %rax, (%r13) + LONG $0xdec1c748; WORD $0xffff; BYTE $0xff // movq $-34, %rcx + LONG $0xffffcbe9; BYTE $0xff // jmp LBB28_247, $-53(%rip) + +LBB28_251: + WORD $0x8948; BYTE $0xd8 // movq %rbx, %rax + +LBB28_252: + WORD $0xf980; BYTE $0x7d // cmpb $125, %cl + LONG $0xffb1850f; WORD $0xffff // jne LBB28_246, $-79(%rip) + +LBB28_253: + WORD $0xff48; BYTE $0xc8 // decq %rax + LONG $0x00458949 // movq %rax, (%r13) + LONG $0xdfc1c748; WORD $0xffff; BYTE $0xff // movq $-33, %rcx + LONG $0xfffface9; BYTE $0xff // jmp LBB28_247, $-84(%rip) + +LBB28_254: + LONG $0xc0458b48 // movq $-64(%rbp), %rax + LONG $0x08408b48 // movq $8(%rax), %rax + LONG $0xc84d8b48 // movq $-56(%rbp), %rcx + WORD $0x8948; BYTE $0x01 // movq %rax, (%rcx) + LONG $0xffc1c748; WORD $0xffff; BYTE $0xff // movq $-1, %rcx + LONG $0xffff91e9; BYTE $0xff // jmp LBB28_247, $-111(%rip) + +LBB28_255: + LONG $0x02c38348 // addq $2, %rbx + LONG $0xfec1c748; WORD $0xffff; BYTE $0xff // movq $-2, %rcx + LONG $0x000012e9; BYTE $0x00 // jmp LBB28_258, $18(%rip) + +LBB28_256: + WORD $0xff48; BYTE $0xc3 // incq %rbx + LONG $0xfdc1c748; WORD $0xffff; BYTE $0xff // movq $-3, %rcx + LONG $0x000003e9; BYTE $0x00 // jmp LBB28_258, $3(%rip) + +LBB28_257: + WORD $0xff48; BYTE $0xc3 // incq %rbx + +LBB28_258: + WORD $0x294c; BYTE $0xcb // subq %r9, %rbx + LONG $0x005d8949 // movq %rbx, (%r13) + LONG $0xffff63e9; BYTE $0xff // jmp LBB28_247, $-157(%rip) + +LBB28_259: + LONG $0xfec1c748; WORD $0xffff; BYTE $0xff // movq $-2, %rcx + LONG $0x000007e9; BYTE $0x00 // jmp LBB28_261, $7(%rip) + +LBB28_260: + LONG $0xfcc1c748; WORD $0xffff; BYTE $0xff // movq $-4, %rcx + +LBB28_261: + WORD $0x894c; BYTE $0xd3 // movq %r10, %rbx + LONG $0xc86d8b4c // movq $-56(%rbp), %r13 + LONG $0xffffd5e9; BYTE $0xff // jmp LBB28_258, $-43(%rip) + LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + _validate_utf8: - BYTE $0x55 // pushq %rbp - WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp - WORD $0x5741 // pushq %r15 - WORD $0x5641 // pushq %r14 - WORD $0x5441 // pushq %r12 - BYTE $0x53 // pushq %rbx - BYTE $0x50 // pushq %rax - WORD $0x8b4c; BYTE $0x17 // movq (%rdi), %r10 - LONG $0x085f8b4c // movq $8(%rdi), %r11 - WORD $0x8b48; BYTE $0x0e // movq (%rsi), %rcx - WORD $0x014c; BYTE $0xd1 // addq %r10, %rcx - LONG $0x1a048d4f // leaq (%r10,%r11), %r8 - LONG $0xfdc08349 // addq $-3, %r8 - LONG $0x00000de9; BYTE $0x00 // jmp LBB34_1, $13(%rip) - QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90 + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5741 // pushq %r15 + WORD $0x5641 // pushq %r14 + WORD $0x5441 // pushq %r12 + BYTE $0x53 // pushq %rbx + BYTE $0x50 // pushq %rax + WORD $0x8b4c; BYTE $0x17 // movq (%rdi), %r10 + LONG $0x085f8b4c // movq $8(%rdi), %r11 + WORD $0x8b48; BYTE $0x0e // movq (%rsi), %rcx + WORD $0x014c; BYTE $0xd1 // addq %r10, %rcx + LONG $0x1a448d4f; BYTE $0xfd // leaq $-3(%r10,%r11), %r8 + LONG $0x000010e9; BYTE $0x00 // jmp LBB29_1, $16(%rip) + QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 -LBB34_19: +LBB29_19: WORD $0x0148; BYTE $0xd9 // addq %rbx, %rcx -LBB34_1: +LBB29_1: WORD $0x394c; BYTE $0xc1 // cmpq %r8, %rcx - LONG $0x00e1830f; WORD $0x0000 // jae LBB34_2, $225(%rip) + LONG $0x00e1830f; WORD $0x0000 // jae LBB29_2, $225(%rip) LONG $0x000001bb; BYTE $0x00 // movl $1, %ebx WORD $0x3980; BYTE $0x00 // cmpb $0, (%rcx) - LONG $0xffe6890f; WORD $0xffff // jns LBB34_19, $-26(%rip) + LONG $0xffe6890f; WORD $0xffff // jns LBB29_19, $-26(%rip) WORD $0x018b // movl (%rcx), %eax WORD $0xc789 // movl %eax, %edi LONG $0xc0f0e781; WORD $0x00c0 // andl $12632304, %edi LONG $0x80e0ff81; WORD $0x0080 // cmpl $8421600, %edi - LONG $0x0030850f; WORD $0x0000 // jne LBB34_10, $48(%rip) + LONG $0x0030850f; WORD $0x0000 // jne LBB29_10, $48(%rip) WORD $0xc789 // movl %eax, %edi LONG $0x200fe781; WORD $0x0000 // andl $8207, %edi LONG $0x200dff81; WORD $0x0000 // cmpl $8205, %edi - LONG $0x001c840f; WORD $0x0000 // je LBB34_10, $28(%rip) + LONG $0x001c840f; WORD $0x0000 // je LBB29_10, $28(%rip) LONG $0x000003bb; BYTE $0x00 // movl $3, %ebx WORD $0xff85 // testl %edi, %edi - LONG $0xffaf850f; WORD $0xffff // jne LBB34_19, $-81(%rip) + LONG $0xffaf850f; WORD $0xffff // jne LBB29_19, $-81(%rip) QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 -LBB34_10: +LBB29_10: WORD $0xc789 // movl %eax, %edi LONG $0xc0e0e781; WORD $0x0000 // andl $49376, %edi LONG $0x80c0ff81; WORD $0x0000 // cmpl $32960, %edi - LONG $0x0010850f; WORD $0x0000 // jne LBB34_12, $16(%rip) + LONG $0x0010850f; WORD $0x0000 // jne LBB29_12, $16(%rip) WORD $0xc789 // movl %eax, %edi LONG $0x000002bb; BYTE $0x00 // movl $2, %ebx WORD $0xe783; BYTE $0x1e // andl $30, %edi - LONG $0xff7c850f; WORD $0xffff // jne LBB34_19, $-132(%rip) + LONG $0xff7c850f; WORD $0xffff // jne LBB29_19, $-132(%rip) -LBB34_12: +LBB29_12: WORD $0xc789 // movl %eax, %edi LONG $0xc0f8e781; WORD $0xc0c0 // andl $-1061109512, %edi LONG $0x80f0ff81; WORD $0x8080 // cmpl $-2139062032, %edi - LONG $0x0026850f; WORD $0x0000 // jne LBB34_16, $38(%rip) + LONG $0x0026850f; WORD $0x0000 // jne LBB29_16, $38(%rip) WORD $0xc789 // movl %eax, %edi LONG $0x3007e781; WORD $0x0000 // andl $12295, %edi - LONG $0x0018840f; WORD $0x0000 // je LBB34_16, $24(%rip) + LONG $0x0018840f; WORD $0x0000 // je LBB29_16, $24(%rip) LONG $0x000004bb; BYTE $0x00 // movl $4, %ebx WORD $0x04a8 // testb $4, %al - LONG $0xff4d840f; WORD $0xffff // je LBB34_19, $-179(%rip) + LONG $0xff4d840f; WORD $0xffff // je LBB29_19, $-179(%rip) LONG $0x00300325; BYTE $0x00 // andl $12291, %eax - LONG $0xff42840f; WORD $0xffff // je LBB34_19, $-190(%rip) + LONG $0xff42840f; WORD $0xffff // je LBB29_19, $-190(%rip) -LBB34_16: +LBB29_16: WORD $0x8948; BYTE $0xcf // movq %rcx, %rdi WORD $0x294c; BYTE $0xd7 // subq %r10, %rdi WORD $0x8b48; BYTE $0x1a // movq (%rdx), %rbx LONG $0x00fb8148; WORD $0x0010; BYTE $0x00 // cmpq $4096, %rbx - LONG $0x0187830f; WORD $0x0000 // jae LBB34_17, $391(%rip) + LONG $0x0187830f; WORD $0x0000 // jae LBB29_17, $391(%rip) WORD $0x6348; BYTE $0xc7 // movslq %edi, %rax LONG $0x017b8d48 // leaq $1(%rbx), %rdi WORD $0x8948; BYTE $0x3a // movq %rdi, (%rdx) LONG $0xda448948; BYTE $0x08 // movq %rax, $8(%rdx,%rbx,8) LONG $0x000001bb; BYTE $0x00 // movl $1, %ebx - LONG $0xffff13e9; BYTE $0xff // jmp LBB34_19, $-237(%rip) + LONG $0xffff13e9; BYTE $0xff // jmp LBB29_19, $-237(%rip) -LBB34_2: +LBB29_2: WORD $0x014d; BYTE $0xd3 // addq %r10, %r11 WORD $0x394c; BYTE $0xd9 // cmpq %r11, %rcx - LONG $0x013e830f; WORD $0x0000 // jae LBB34_36, $318(%rip) + LONG $0x013e830f; WORD $0x0000 // jae LBB29_36, $318(%rip) LONG $0xdc458d4c // leaq $-36(%rbp), %r8 LONG $0xda4d8d4c // leaq $-38(%rbp), %r9 - LONG $0x000016e9; BYTE $0x00 // jmp LBB34_4, $22(%rip) + LONG $0x000016e9; BYTE $0x00 // jmp LBB29_4, $22(%rip) QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90 -LBB34_5: +LBB29_5: WORD $0xff48; BYTE $0xc1 // incq %rcx WORD $0x394c; BYTE $0xd9 // cmpq %r11, %rcx - LONG $0x011b830f; WORD $0x0000 // jae LBB34_36, $283(%rip) + LONG $0x011b830f; WORD $0x0000 // jae LBB29_36, $283(%rip) -LBB34_4: +LBB29_4: WORD $0x3980; BYTE $0x00 // cmpb $0, (%rcx) - LONG $0xffeb890f; WORD $0xffff // jns LBB34_5, $-21(%rip) + LONG $0xffeb890f; WORD $0xffff // jns LBB29_5, $-21(%rip) LONG $0x00dc45c6 // movb $0, $-36(%rbp) LONG $0x00da45c6 // movb $0, $-38(%rbp) WORD $0x894c; BYTE $0xdb // movq %r11, %rbx WORD $0x2948; BYTE $0xcb // subq %rcx, %rbx LONG $0x02fb8348 // cmpq $2, %rbx - LONG $0x0035820f; WORD $0x0000 // jb LBB34_21, $53(%rip) + LONG $0x0035820f; WORD $0x0000 // jb LBB29_21, $53(%rip) LONG $0x21b60f44 // movzbl (%rcx), %r12d LONG $0x71b60f44; BYTE $0x01 // movzbl $1(%rcx), %r14d LONG $0xdc658844 // movb %r12b, $-36(%rbp) @@ -8390,67 +8817,66 @@ LBB34_4: LONG $0xfec38348 // addq $-2, %rbx WORD $0x894c; BYTE $0xcf // movq %r9, %rdi WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx - LONG $0x0029840f; WORD $0x0000 // je LBB34_24, $41(%rip) + LONG $0x0029840f; WORD $0x0000 // je LBB29_24, $41(%rip) -LBB34_25: +LBB29_25: LONG $0x07b60f41 // movzbl (%r15), %eax WORD $0x0788 // movb %al, (%rdi) LONG $0x65b60f44; BYTE $0xdc // movzbl $-36(%rbp), %r12d LONG $0xda7db60f // movzbl $-38(%rbp), %edi - LONG $0x000017e9; BYTE $0x00 // jmp LBB34_26, $23(%rip) + LONG $0x000017e9; BYTE $0x00 // jmp LBB29_26, $23(%rip) -LBB34_21: +LBB29_21: WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d WORD $0x894c; BYTE $0xc7 // movq %r8, %rdi WORD $0x8949; BYTE $0xcf // movq %rcx, %r15 WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx - LONG $0xffd7850f; WORD $0xffff // jne LBB34_25, $-41(%rip) + LONG $0xffd7850f; WORD $0xffff // jne LBB29_25, $-41(%rip) -LBB34_24: +LBB29_24: WORD $0xff31 // xorl %edi, %edi -LBB34_26: +LBB29_26: LONG $0xc7b60f40 // movzbl %dil, %eax WORD $0xe0c1; BYTE $0x10 // shll $16, %eax LONG $0xdeb60f41 // movzbl %r14b, %ebx WORD $0xe3c1; BYTE $0x08 // shll $8, %ebx - WORD $0xc309 // orl %eax, %ebx LONG $0xfcb60f41 // movzbl %r12b, %edi WORD $0xdf09 // orl %ebx, %edi - WORD $0xf889 // movl %edi, %eax + WORD $0xf809 // orl %edi, %eax LONG $0xc0c0f025; BYTE $0x00 // andl $12632304, %eax LONG $0x8080e03d; BYTE $0x00 // cmpl $8421600, %eax - LONG $0x001f850f; WORD $0x0000 // jne LBB34_29, $31(%rip) + LONG $0x0021850f; WORD $0x0000 // jne LBB29_29, $33(%rip) WORD $0xf889 // movl %edi, %eax LONG $0x00200f25; BYTE $0x00 // andl $8207, %eax LONG $0x00200d3d; BYTE $0x00 // cmpl $8205, %eax - LONG $0x000d840f; WORD $0x0000 // je LBB34_29, $13(%rip) + LONG $0x000f840f; WORD $0x0000 // je LBB29_29, $15(%rip) LONG $0x000003bb; BYTE $0x00 // movl $3, %ebx WORD $0xc085 // testl %eax, %eax - LONG $0x0021850f; WORD $0x0000 // jne LBB34_34, $33(%rip) + LONG $0x0023850f; WORD $0x0000 // jne LBB29_34, $35(%rip) + WORD $0x9090 // .p2align 4, 0x90 - // .p2align 4, 0x90 -LBB34_29: +LBB29_29: LONG $0x1ec4f641 // testb $30, %r12b - LONG $0x0028840f; WORD $0x0000 // je LBB34_31, $40(%rip) + LONG $0x0028840f; WORD $0x0000 // je LBB29_31, $40(%rip) LONG $0xc0e0e781; WORD $0x0000 // andl $49376, %edi LONG $0x000002bb; BYTE $0x00 // movl $2, %ebx LONG $0x80c0ff81; WORD $0x0000 // cmpl $32960, %edi - LONG $0x0011850f; WORD $0x0000 // jne LBB34_31, $17(%rip) + LONG $0x0011850f; WORD $0x0000 // jne LBB29_31, $17(%rip) -LBB34_34: +LBB29_34: WORD $0x0148; BYTE $0xd9 // addq %rbx, %rcx WORD $0x394c; BYTE $0xd9 // cmpq %r11, %rcx - LONG $0xff1f820f; WORD $0xffff // jb LBB34_4, $-225(%rip) - LONG $0x000035e9; BYTE $0x00 // jmp LBB34_36, $53(%rip) + LONG $0xff1f820f; WORD $0xffff // jb LBB29_4, $-225(%rip) + LONG $0x000035e9; BYTE $0x00 // jmp LBB29_36, $53(%rip) -LBB34_31: +LBB29_31: WORD $0x8948; BYTE $0xc8 // movq %rcx, %rax WORD $0x294c; BYTE $0xd0 // subq %r10, %rax WORD $0x8b48; BYTE $0x3a // movq (%rdx), %rdi LONG $0x00ff8148; WORD $0x0010; BYTE $0x00 // cmpq $4096, %rdi - LONG $0x0034830f; WORD $0x0000 // jae LBB34_32, $52(%rip) + LONG $0x0034830f; WORD $0x0000 // jae LBB29_32, $52(%rip) WORD $0x9848 // cltq LONG $0x015f8d48 // leaq $1(%rdi), %rbx WORD $0x8948; BYTE $0x1a // movq %rbx, (%rdx) @@ -8458,14 +8884,14 @@ LBB34_31: LONG $0x000001bb; BYTE $0x00 // movl $1, %ebx WORD $0x0148; BYTE $0xd9 // addq %rbx, %rcx WORD $0x394c; BYTE $0xd9 // cmpq %r11, %rcx - LONG $0xfee5820f; WORD $0xffff // jb LBB34_4, $-283(%rip) + LONG $0xfee5820f; WORD $0xffff // jb LBB29_4, $-283(%rip) -LBB34_36: +LBB29_36: WORD $0x294c; BYTE $0xd1 // subq %r10, %rcx WORD $0x8948; BYTE $0x0e // movq %rcx, (%rsi) WORD $0xc031 // xorl %eax, %eax -LBB34_37: +LBB29_37: LONG $0x08c48348 // addq $8, %rsp BYTE $0x5b // popq %rbx WORD $0x5c41 // popq %r12 @@ -8474,81 +8900,80 @@ LBB34_37: BYTE $0x5d // popq %rbp BYTE $0xc3 // retq -LBB34_32: +LBB29_32: WORD $0x8948; BYTE $0x06 // movq %rax, (%rsi) LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax - LONG $0xffffe4e9; BYTE $0xff // jmp LBB34_37, $-28(%rip) + LONG $0xffffe4e9; BYTE $0xff // jmp LBB29_37, $-28(%rip) -LBB34_17: +LBB29_17: WORD $0x8948; BYTE $0x3e // movq %rdi, (%rsi) LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax - LONG $0xffffd5e9; BYTE $0xff // jmp LBB34_37, $-43(%rip) + LONG $0xffffd5e9; BYTE $0xff // jmp LBB29_37, $-43(%rip) LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 _validate_utf8_fast: - BYTE $0x55 // pushq %rbp - WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp - BYTE $0x53 // pushq %rbx - BYTE $0x50 // pushq %rax - WORD $0x8b4c; BYTE $0x17 // movq (%rdi), %r10 - LONG $0x085f8b4c // movq $8(%rdi), %r11 - LONG $0x1a348d4b // leaq (%r10,%r11), %rsi - LONG $0xfdc68348 // addq $-3, %rsi - WORD $0x894c; BYTE $0xd0 // movq %r10, %rax - WORD $0x394c; BYTE $0xd6 // cmpq %r10, %rsi - LONG $0x00dd860f; WORD $0x0000 // jbe LBB35_14, $221(%rip) - WORD $0x894c; BYTE $0xd0 // movq %r10, %rax - LONG $0x000013e9; BYTE $0x00 // jmp LBB35_3, $19(%rip) - LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + BYTE $0x53 // pushq %rbx + BYTE $0x50 // pushq %rax + WORD $0x8b4c; BYTE $0x17 // movq (%rdi), %r10 + LONG $0x085f8b4c // movq $8(%rdi), %r11 + LONG $0x1a748d4b; BYTE $0xfd // leaq $-3(%r10,%r11), %rsi + WORD $0x894c; BYTE $0xd0 // movq %r10, %rax + WORD $0x3949; BYTE $0xf2 // cmpq %rsi, %r10 + LONG $0x00e0830f; WORD $0x0000 // jae LBB30_14, $224(%rip) + WORD $0x894c; BYTE $0xd0 // movq %r10, %rax + LONG $0x000016e9; BYTE $0x00 // jmp LBB30_3, $22(%rip) + QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90 -LBB35_2: +LBB30_2: WORD $0x0148; BYTE $0xd0 // addq %rdx, %rax WORD $0x3948; BYTE $0xf0 // cmpq %rsi, %rax - LONG $0x00c2830f; WORD $0x0000 // jae LBB35_14, $194(%rip) + LONG $0x00c2830f; WORD $0x0000 // jae LBB30_14, $194(%rip) -LBB35_3: +LBB30_3: LONG $0x000001ba; BYTE $0x00 // movl $1, %edx WORD $0x3880; BYTE $0x00 // cmpb $0, (%rax) - LONG $0xffe6890f; WORD $0xffff // jns LBB35_2, $-26(%rip) + LONG $0xffe6890f; WORD $0xffff // jns LBB30_2, $-26(%rip) WORD $0x388b // movl (%rax), %edi WORD $0xf989 // movl %edi, %ecx LONG $0xc0f0e181; WORD $0x00c0 // andl $12632304, %ecx LONG $0x80e0f981; WORD $0x0080 // cmpl $8421600, %ecx - LONG $0x0030850f; WORD $0x0000 // jne LBB35_7, $48(%rip) + LONG $0x0030850f; WORD $0x0000 // jne LBB30_7, $48(%rip) WORD $0xf989 // movl %edi, %ecx LONG $0x200fe181; WORD $0x0000 // andl $8207, %ecx LONG $0x200df981; WORD $0x0000 // cmpl $8205, %ecx - LONG $0x001c840f; WORD $0x0000 // je LBB35_7, $28(%rip) + LONG $0x001c840f; WORD $0x0000 // je LBB30_7, $28(%rip) LONG $0x000003ba; BYTE $0x00 // movl $3, %edx WORD $0xc985 // testl %ecx, %ecx - LONG $0xffaf850f; WORD $0xffff // jne LBB35_2, $-81(%rip) + LONG $0xffaf850f; WORD $0xffff // jne LBB30_2, $-81(%rip) QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 -LBB35_7: +LBB30_7: WORD $0xf989 // movl %edi, %ecx LONG $0xc0e0e181; WORD $0x0000 // andl $49376, %ecx LONG $0x80c0f981; WORD $0x0000 // cmpl $32960, %ecx - LONG $0x0010850f; WORD $0x0000 // jne LBB35_9, $16(%rip) + LONG $0x0010850f; WORD $0x0000 // jne LBB30_9, $16(%rip) WORD $0xf989 // movl %edi, %ecx LONG $0x000002ba; BYTE $0x00 // movl $2, %edx WORD $0xe183; BYTE $0x1e // andl $30, %ecx - LONG $0xff7c850f; WORD $0xffff // jne LBB35_2, $-132(%rip) + LONG $0xff7c850f; WORD $0xffff // jne LBB30_2, $-132(%rip) -LBB35_9: +LBB30_9: WORD $0xf989 // movl %edi, %ecx LONG $0xc0f8e181; WORD $0xc0c0 // andl $-1061109512, %ecx LONG $0x80f0f981; WORD $0x8080 // cmpl $-2139062032, %ecx - LONG $0x0029850f; WORD $0x0000 // jne LBB35_13, $41(%rip) + LONG $0x0029850f; WORD $0x0000 // jne LBB30_13, $41(%rip) WORD $0xf989 // movl %edi, %ecx LONG $0x3007e181; WORD $0x0000 // andl $12295, %ecx - LONG $0x001b840f; WORD $0x0000 // je LBB35_13, $27(%rip) + LONG $0x001b840f; WORD $0x0000 // je LBB30_13, $27(%rip) LONG $0x000004ba; BYTE $0x00 // movl $4, %edx LONG $0x04c7f640 // testb $4, %dil - LONG $0xff4b840f; WORD $0xffff // je LBB35_2, $-181(%rip) + LONG $0xff4b840f; WORD $0xffff // je LBB30_2, $-181(%rip) LONG $0x3003e781; WORD $0x0000 // andl $12291, %edi - LONG $0xff3f840f; WORD $0xffff // je LBB35_2, $-193(%rip) + LONG $0xff3f840f; WORD $0xffff // je LBB30_2, $-193(%rip) -LBB35_13: +LBB30_13: WORD $0xf748; BYTE $0xd0 // notq %rax WORD $0x014c; BYTE $0xd0 // addq %r10, %rax LONG $0x08c48348 // addq $8, %rsp @@ -8556,29 +8981,29 @@ LBB35_13: BYTE $0x5d // popq %rbp BYTE $0xc3 // retq -LBB35_14: +LBB30_14: WORD $0x014d; BYTE $0xd3 // addq %r10, %r11 WORD $0x394c; BYTE $0xd8 // cmpq %r11, %rax - LONG $0x0103830f; WORD $0x0000 // jae LBB35_30, $259(%rip) + LONG $0x0103830f; WORD $0x0000 // jae LBB30_30, $259(%rip) LONG $0xf4458d4c // leaq $-12(%rbp), %r8 LONG $0xf24d8d4c // leaq $-14(%rbp), %r9 - LONG $0x000015e9; BYTE $0x00 // jmp LBB35_17, $21(%rip) + LONG $0x000015e9; BYTE $0x00 // jmp LBB30_17, $21(%rip) QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90 -LBB35_16: +LBB30_16: WORD $0xff48; BYTE $0xc0 // incq %rax WORD $0x394c; BYTE $0xd8 // cmpq %r11, %rax - LONG $0x00e1830f; WORD $0x0000 // jae LBB35_30, $225(%rip) + LONG $0x00e1830f; WORD $0x0000 // jae LBB30_30, $225(%rip) -LBB35_17: +LBB30_17: WORD $0x3880; BYTE $0x00 // cmpb $0, (%rax) - LONG $0xffeb890f; WORD $0xffff // jns LBB35_16, $-21(%rip) + LONG $0xffeb890f; WORD $0xffff // jns LBB30_16, $-21(%rip) LONG $0x00f445c6 // movb $0, $-12(%rbp) LONG $0x00f245c6 // movb $0, $-14(%rbp) WORD $0x894c; BYTE $0xda // movq %r11, %rdx WORD $0x2948; BYTE $0xc2 // subq %rax, %rdx LONG $0x02fa8348 // cmpq $2, %rdx - LONG $0x0031820f; WORD $0x0000 // jb LBB35_21, $49(%rip) + LONG $0x0031820f; WORD $0x0000 // jb LBB30_21, $49(%rip) WORD $0xb60f; BYTE $0x30 // movzbl (%rax), %esi LONG $0x0178b60f // movzbl $1(%rax), %edi LONG $0xf4758840 // movb %sil, $-12(%rbp) @@ -8586,61 +9011,60 @@ LBB35_17: LONG $0xfec28348 // addq $-2, %rdx WORD $0x894c; BYTE $0xcb // movq %r9, %rbx WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx - LONG $0x0025840f; WORD $0x0000 // je LBB35_22, $37(%rip) + LONG $0x0025840f; WORD $0x0000 // je LBB30_22, $37(%rip) -LBB35_20: +LBB30_20: WORD $0xb60f; BYTE $0x09 // movzbl (%rcx), %ecx WORD $0x0b88 // movb %cl, (%rbx) LONG $0xf475b60f // movzbl $-12(%rbp), %esi LONG $0xf24db60f // movzbl $-14(%rbp), %ecx - LONG $0x000015e9; BYTE $0x00 // jmp LBB35_23, $21(%rip) + LONG $0x000015e9; BYTE $0x00 // jmp LBB30_23, $21(%rip) -LBB35_21: +LBB30_21: WORD $0xf631 // xorl %esi, %esi WORD $0xff31 // xorl %edi, %edi WORD $0x894c; BYTE $0xc3 // movq %r8, %rbx WORD $0x8948; BYTE $0xc1 // movq %rax, %rcx WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx - LONG $0xffdb850f; WORD $0xffff // jne LBB35_20, $-37(%rip) + LONG $0xffdb850f; WORD $0xffff // jne LBB30_20, $-37(%rip) -LBB35_22: +LBB30_22: WORD $0xc931 // xorl %ecx, %ecx -LBB35_23: +LBB30_23: WORD $0xb60f; BYTE $0xc9 // movzbl %cl, %ecx WORD $0xe1c1; BYTE $0x10 // shll $16, %ecx LONG $0xffb60f40 // movzbl %dil, %edi WORD $0xe7c1; BYTE $0x08 // shll $8, %edi - WORD $0xcf09 // orl %ecx, %edi LONG $0xd6b60f40 // movzbl %sil, %edx WORD $0xfa09 // orl %edi, %edx - WORD $0xd189 // movl %edx, %ecx + WORD $0xd109 // orl %edx, %ecx LONG $0xc0f0e181; WORD $0x00c0 // andl $12632304, %ecx LONG $0x80e0f981; WORD $0x0080 // cmpl $8421600, %ecx - LONG $0x0024850f; WORD $0x0000 // jne LBB35_26, $36(%rip) + LONG $0x0026850f; WORD $0x0000 // jne LBB30_26, $38(%rip) WORD $0xd789 // movl %edx, %edi LONG $0x200fe781; WORD $0x0000 // andl $8207, %edi LONG $0x200dff81; WORD $0x0000 // cmpl $8205, %edi - LONG $0x0010840f; WORD $0x0000 // je LBB35_26, $16(%rip) + LONG $0x0012840f; WORD $0x0000 // je LBB30_26, $18(%rip) LONG $0x000003b9; BYTE $0x00 // movl $3, %ecx WORD $0xff85 // testl %edi, %edi - LONG $0x0024850f; WORD $0x0000 // jne LBB35_28, $36(%rip) - WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + LONG $0x0026850f; WORD $0x0000 // jne LBB30_28, $38(%rip) + LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 -LBB35_26: +LBB30_26: LONG $0x1ec6f640 // testb $30, %sil - LONG $0xff07840f; WORD $0xffff // je LBB35_13, $-249(%rip) + LONG $0xff07840f; WORD $0xffff // je LBB30_13, $-249(%rip) LONG $0xc0e0e281; WORD $0x0000 // andl $49376, %edx LONG $0x000002b9; BYTE $0x00 // movl $2, %ecx LONG $0x80c0fa81; WORD $0x0000 // cmpl $32960, %edx - LONG $0xfef0850f; WORD $0xffff // jne LBB35_13, $-272(%rip) + LONG $0xfef0850f; WORD $0xffff // jne LBB30_13, $-272(%rip) -LBB35_28: +LBB30_28: WORD $0x0148; BYTE $0xc8 // addq %rcx, %rax WORD $0x394c; BYTE $0xd8 // cmpq %r11, %rax - LONG $0xff1f820f; WORD $0xffff // jb LBB35_17, $-225(%rip) + LONG $0xff1f820f; WORD $0xffff // jb LBB30_17, $-225(%rip) -LBB35_30: +LBB30_30: WORD $0xc031 // xorl %eax, %eax LONG $0x08c48348 // addq $8, %rsp BYTE $0x5b // popq %rbx @@ -8648,14 +9072,10 @@ LBB35_30: BYTE $0xc3 // retq QUAD $0x0000000000000000; QUAD $0x0000000000000000; QUAD $0x0000000000000000; WORD $0x0000 // .p2align 5, 0x00 -LCPI36_0: +LCPI31_0: QUAD $0x3030303030303030; QUAD $0x3030303030303030 // .space 16, '0000000000000000' QUAD $0x3030303030303030; QUAD $0x3030303030303030 // .space 16, '0000000000000000' - // .p2align 4, 0x00 -LCPI36_1: - QUAD $0x3030303030303030; QUAD $0x3030303030303030 // .space 16, '0000000000000000' - // .p2align 4, 0x90 _f32toa: BYTE $0x55 // pushq %rbp @@ -8665,1004 +9085,904 @@ _f32toa: WORD $0x5541 // pushq %r13 WORD $0x5441 // pushq %r12 BYTE $0x53 // pushq %rbx - BYTE $0x50 // pushq %rax LONG $0xc07ef9c5 // vmovd %xmm0, %eax WORD $0xc189 // movl %eax, %ecx WORD $0xe9c1; BYTE $0x17 // shrl $23, %ecx - WORD $0xb60f; BYTE $0xd1 // movzbl %cl, %edx - LONG $0x00fffa81; WORD $0x0000 // cmpl $255, %edx - LONG $0x0df0840f; WORD $0x0000 // je LBB36_141, $3568(%rip) + WORD $0xb60f; BYTE $0xd9 // movzbl %cl, %ebx + LONG $0x00fffb81; WORD $0x0000 // cmpl $255, %ebx + LONG $0x0cf1840f; WORD $0x0000 // je LBB31_138, $3313(%rip) WORD $0x07c6; BYTE $0x2d // movb $45, (%rdi) WORD $0x8941; BYTE $0xc1 // movl %eax, %r9d LONG $0x1fe9c141 // shrl $31, %r9d - LONG $0x0f2c8d4e // leaq (%rdi,%r9), %r13 + LONG $0x0f048d4e // leaq (%rdi,%r9), %r8 LONG $0xffffffa9; BYTE $0x7f // testl $2147483647, %eax - LONG $0x01cd840f; WORD $0x0000 // je LBB36_6, $461(%rip) + LONG $0x01bf840f; WORD $0x0000 // je LBB31_11, $447(%rip) LONG $0x7fffff25; BYTE $0x00 // andl $8388607, %eax - WORD $0xd285 // testl %edx, %edx - LONG $0x0dd1840f; WORD $0x0000 // je LBB36_142, $3537(%rip) - LONG $0x00b88d44; WORD $0x8000; BYTE $0x00 // leal $8388608(%rax), %r15d - LONG $0x6a828d44; WORD $0xffff; BYTE $0xff // leal $-150(%rdx), %r8d - WORD $0x4a8d; BYTE $0x81 // leal $-127(%rdx), %ecx + WORD $0xdb85 // testl %ebx, %ebx + LONG $0x0cd3840f; WORD $0x0000 // je LBB31_139, $3283(%rip) + LONG $0x0000b08d; WORD $0x0080 // leal $8388608(%rax), %esi + LONG $0x6abb8d44; WORD $0xffff; BYTE $0xff // leal $-150(%rbx), %r15d + WORD $0x4b8d; BYTE $0x81 // leal $-127(%rbx), %ecx WORD $0xf983; BYTE $0x17 // cmpl $23, %ecx - LONG $0x001c870f; WORD $0x0000 // ja LBB36_7, $28(%rip) - LONG $0x000096b9; BYTE $0x00 // movl $150, %ecx - WORD $0xd129 // subl %edx, %ecx - LONG $0xffc3c748; WORD $0xffff; BYTE $0xff // movq $-1, %rbx - WORD $0xd348; BYTE $0xe3 // shlq %cl, %rbx - WORD $0xd3f7 // notl %ebx - WORD $0x8544; BYTE $0xfb // testl %r15d, %ebx - LONG $0x043c840f; WORD $0x0000 // je LBB36_33, $1084(%rip) - -LBB36_7: - LONG $0xd07d8948 // movq %rdi, $-48(%rbp) - -LBB36_8: - WORD $0x8945; BYTE $0xfe // movl %r15d, %r14d + LONG $0x0019870f; WORD $0x0000 // ja LBB31_5, $25(%rip) + WORD $0x8944; BYTE $0xf9 // movl %r15d, %ecx + WORD $0xd9f7 // negl %ecx + LONG $0xffc2c748; WORD $0xffff; BYTE $0xff // movq $-1, %rdx + WORD $0xd348; BYTE $0xe2 // shlq %cl, %rdx + WORD $0xd2f7 // notl %edx + WORD $0xf285 // testl %esi, %edx + LONG $0x03fc840f; WORD $0x0000 // je LBB31_32, $1020(%rip) + +LBB31_5: + WORD $0x8941; BYTE $0xf6 // movl %esi, %r14d LONG $0x01e68341 // andl $1, %r14d WORD $0xc085 // testl %eax, %eax WORD $0x940f; BYTE $0xc0 // sete %al - WORD $0xfa83; BYTE $0x02 // cmpl $2, %edx - WORD $0x930f; BYTE $0xc1 // setae %cl + WORD $0xfb83; BYTE $0x01 // cmpl $1, %ebx + WORD $0x970f; BYTE $0xc1 // seta %cl WORD $0xc120 // andb %al, %cl WORD $0xb60f; BYTE $0xc9 // movzbl %cl, %ecx - WORD $0x8945; BYTE $0xfa // movl %r15d, %r10d + WORD $0x8941; BYTE $0xf2 // movl %esi, %r10d LONG $0x02e2c141 // shll $2, %r10d - LONG $0xb9048d42 // leal (%rcx,%r15,4), %eax - WORD $0xc083; BYTE $0xfe // addl $-2, %eax - LONG $0x13d06941; WORD $0x1344; BYTE $0x00 // imull $1262611, %r8d, %edx - LONG $0x019a8d44; WORD $0xf801; BYTE $0xff // leal $-524031(%rdx), %r11d + LONG $0xfeb1448d // leal $-2(%rcx,%rsi,4), %eax + LONG $0x13d76941; WORD $0x1344; BYTE $0x00 // imull $1262611, %r15d, %edx + WORD $0xdb31 // xorl %ebx, %ebx WORD $0xc984 // testb %cl, %cl - LONG $0xda440f44 // cmovel %edx, %r11d + LONG $0x0101bb41; WORD $0xfff8 // movl $-524031, %r11d + LONG $0xdb440f44 // cmovel %ebx, %r11d + WORD $0x0141; BYTE $0xd3 // addl %edx, %r11d LONG $0x16fbc141 // sarl $22, %r11d LONG $0xb1cb6941; WORD $0xe56c; BYTE $0xff // imull $-1741647, %r11d, %ecx WORD $0xe9c1; BYTE $0x13 // shrl $19, %ecx - WORD $0x0144; BYTE $0xc1 // addl %r8d, %ecx + WORD $0x0144; BYTE $0xf9 // addl %r15d, %ecx LONG $0x00001fba; BYTE $0x00 // movl $31, %edx WORD $0x2944; BYTE $0xda // subl %r11d, %edx - LONG $0xc13d8d48; WORD $0x00b8; BYTE $0x00 // leaq $47297(%rip), %rdi /* _pow10_ceil_sig_f32.g(%rip) */ + LONG $0x991d8d48; WORD $0x00b4; BYTE $0x00 // leaq $46233(%rip), %rbx /* _pow10_ceil_sig_f32.g(%rip) */ WORD $0xc1fe // incb %cl WORD $0xe0d3 // shll %cl, %eax - LONG $0xd7248b4c // movq (%rdi,%rdx,8), %r12 + LONG $0xd3248b4c // movq (%rbx,%rdx,8), %r12 WORD $0xf749; BYTE $0xe4 // mulq %r12 - QUAD $0x00000002bd048d46 // leal $2(,%r15,4), %r8d - WORD $0xf631 // xorl %esi, %esi - LONG $0x21e8c148 // shrq $33, %rax - LONG $0xc6950f40 // setne %sil - WORD $0xd609 // orl %edx, %esi + LONG $0x20e8c148 // shrq $32, %rax + WORD $0xdb31 // xorl %ebx, %ebx + WORD $0xf883; BYTE $0x01 // cmpl $1, %eax + WORD $0x970f; BYTE $0xc3 // seta %bl WORD $0xd341; BYTE $0xe2 // shll %cl, %r10d + WORD $0xd309 // orl %edx, %ebx WORD $0x894c; BYTE $0xd0 // movq %r10, %rax WORD $0xf749; BYTE $0xe4 // mulq %r12 WORD $0x8949; BYTE $0xd2 // movq %rdx, %r10 + LONG $0x20e8c148 // shrq $32, %rax WORD $0x3145; BYTE $0xff // xorl %r15d, %r15d - LONG $0x21e8c148 // shrq $33, %rax - LONG $0xc7950f41 // setne %r15b + WORD $0xf883; BYTE $0x01 // cmpl $1, %eax + LONG $0xc7970f41 // seta %r15b + LONG $0x02b5048d; WORD $0x0000; BYTE $0x00 // leal $2(,%rsi,4), %eax + WORD $0xe0d3 // shll %cl, %eax WORD $0x0945; BYTE $0xd7 // orl %r10d, %r15d - WORD $0xd341; BYTE $0xe0 // shll %cl, %r8d - WORD $0x894c; BYTE $0xc0 // movq %r8, %rax WORD $0xf749; BYTE $0xe4 // mulq %r12 + LONG $0x20e8c148 // shrq $32, %rax WORD $0xc931 // xorl %ecx, %ecx - LONG $0x21e8c148 // shrq $33, %rax - WORD $0x950f; BYTE $0xc1 // setne %cl + WORD $0xf883; BYTE $0x01 // cmpl $1, %eax + WORD $0x970f; BYTE $0xc1 // seta %cl WORD $0xd109 // orl %edx, %ecx - WORD $0x0144; BYTE $0xf6 // addl %r14d, %esi + WORD $0x0144; BYTE $0xf3 // addl %r14d, %ebx WORD $0x2944; BYTE $0xf1 // subl %r14d, %ecx LONG $0x28ff8341 // cmpl $40, %r15d - LONG $0x0041820f; WORD $0x0000 // jb LBB36_10, $65(%rip) + LONG $0x003d820f; WORD $0x0000 // jb LBB31_7, $61(%rip) WORD $0x8944; BYTE $0xd0 // movl %r10d, %eax - LONG $0xcccccdba; BYTE $0xcc // movl $3435973837, %edx - LONG $0xd0af0f48 // imulq %rax, %rdx - LONG $0x25eac148 // shrq $37, %rdx - WORD $0xf089 // movl %esi, %eax - QUAD $0x00000000d53c8d48 // leaq (,%rdx,8), %rdi - LONG $0xbf1c8d48 // leaq (%rdi,%rdi,4), %rbx - WORD $0x3948; BYTE $0xc3 // cmpq %rax, %rbx + LONG $0xcccdbd41; WORD $0xcccc // movl $3435973837, %r13d + LONG $0xe8af0f4c // imulq %rax, %r13 + LONG $0x25edc149 // shrq $37, %r13 + WORD $0x8941; BYTE $0xde // movl %ebx, %r14d + QUAD $0x00000000ed348d4a // leaq (,%r13,8), %rsi + LONG $0xb6048d48 // leaq (%rsi,%rsi,4), %rax + WORD $0x394c; BYTE $0xf0 // cmpq %r14, %rax LONG $0xc6920f41 // setb %r14b - LONG $0xbf3c8d48 // leaq (%rdi,%rdi,4), %rdi - LONG $0x28c78348 // addq $40, %rdi - WORD $0xcb89 // movl %ecx, %ebx - WORD $0xc031 // xorl %eax, %eax - WORD $0x3948; BYTE $0xdf // cmpq %rbx, %rdi - LONG $0xc0960f41 // setbe %r8b - WORD $0x3845; BYTE $0xc6 // cmpb %r8b, %r14b - LONG $0x01f9840f; WORD $0x0000 // je LBB36_18, $505(%rip) - -LBB36_10: - WORD $0x8945; BYTE $0xd0 // movl %r10d, %r8d - LONG $0x02e8c141 // shrl $2, %r8d - WORD $0x8944; BYTE $0xd2 // movl %r10d, %edx - WORD $0xe283; BYTE $0xfc // andl $-4, %edx - WORD $0xd639 // cmpl %edx, %esi - LONG $0xc6970f40 // seta %sil - WORD $0x428d; BYTE $0x04 // leal $4(%rdx), %eax - WORD $0xc839 // cmpl %ecx, %eax + LONG $0xb6648d4c; BYTE $0x28 // leaq $40(%rsi,%rsi,4), %r12 + WORD $0xce89 // movl %ecx, %esi + WORD $0x3949; BYTE $0xf4 // cmpq %rsi, %r12 + WORD $0x960f; BYTE $0xc0 // setbe %al + WORD $0x3044; BYTE $0xf0 // xorb %r14b, %al + LONG $0x01e9840f; WORD $0x0000 // je LBB31_16, $489(%rip) + +LBB31_7: + WORD $0x894c; BYTE $0xd0 // movq %r10, %rax + LONG $0x02e8c148 // shrq $2, %rax + WORD $0x8944; BYTE $0xd6 // movl %r10d, %esi + WORD $0xe683; BYTE $0xfc // andl $-4, %esi + WORD $0xf339 // cmpl %esi, %ebx + LONG $0xc6970f41 // seta %r14b + WORD $0x568d; BYTE $0x04 // leal $4(%rsi), %edx + WORD $0xca39 // cmpl %ecx, %edx WORD $0x960f; BYTE $0xc3 // setbe %bl - WORD $0x3040; BYTE $0xf3 // xorb %sil, %bl - LONG $0x007e840f; WORD $0x0000 // je LBB36_14, $126(%rip) - WORD $0xca83; BYTE $0x02 // orl $2, %edx - LONG $0x000001b8; BYTE $0x00 // movl $1, %eax - WORD $0x3941; BYTE $0xd7 // cmpl %edx, %r15d - LONG $0x000e870f; WORD $0x0000 // ja LBB36_13, $14(%rip) - WORD $0x940f; BYTE $0xc0 // sete %al + WORD $0x3044; BYTE $0xf3 // xorb %r14b, %bl + LONG $0x0074840f; WORD $0x0000 // je LBB31_12, $116(%rip) + WORD $0xce83; BYTE $0x02 // orl $2, %esi + LONG $0x0001bd41; WORD $0x0000 // movl $1, %r13d + WORD $0x3941; BYTE $0xf7 // cmpl %esi, %r15d + LONG $0x000e870f; WORD $0x0000 // ja LBB31_10, $14(%rip) + WORD $0x940f; BYTE $0xc1 // sete %cl LONG $0x02eac041 // shrb $2, %r10b - WORD $0x2041; BYTE $0xc2 // andb %al, %r10b - LONG $0xc2b60f41 // movzbl %r10b, %eax - -LBB36_13: - WORD $0x0144; BYTE $0xc0 // addl %r8d, %eax - WORD $0x894d; BYTE $0xef // movq %r13, %r15 - LONG $0x0186a03d; BYTE $0x00 // cmpl $100000, %eax - LONG $0xd06d8b4c // movq $-48(%rbp), %r13 - LONG $0x0065820f; WORD $0x0000 // jb LBB36_19, $101(%rip) - -LBB36_15: - LONG $0x0006bc41; WORD $0x0000 // movl $6, %r12d - LONG $0x0f42403d; BYTE $0x00 // cmpl $1000000, %eax - LONG $0x0093820f; WORD $0x0000 // jb LBB36_23, $147(%rip) - LONG $0x0007bc41; WORD $0x0000 // movl $7, %r12d - LONG $0x9896803d; BYTE $0x00 // cmpl $10000000, %eax - LONG $0x0082820f; WORD $0x0000 // jb LBB36_23, $130(%rip) - WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d - LONG $0xf5e1003d; BYTE $0x05 // cmpl $100000000, %eax - LONG $0xc4920f41 // setb %r12b - LONG $0x09f48341 // xorl $9, %r12d - LONG $0x00006de9; BYTE $0x00 // jmp LBB36_23, $109(%rip) - -LBB36_6: - LONG $0x0045c641; BYTE $0x30 // movb $48, (%r13) - WORD $0x2941; BYTE $0xfd // subl %edi, %r13d - WORD $0xff41; BYTE $0xc5 // incl %r13d - WORD $0x8944; BYTE $0xe8 // movl %r13d, %eax - LONG $0x000be5e9; BYTE $0x00 // jmp LBB36_93, $3045(%rip) - -LBB36_14: - WORD $0xc139 // cmpl %eax, %ecx - LONG $0xffd88341 // sbbl $-1, %r8d - WORD $0x8944; BYTE $0xc0 // movl %r8d, %eax - WORD $0x894d; BYTE $0xef // movq %r13, %r15 - LONG $0x0186a03d; BYTE $0x00 // cmpl $100000, %eax - LONG $0xd06d8b4c // movq $-48(%rbp), %r13 - LONG $0xff9b830f; WORD $0xffff // jae LBB36_15, $-101(%rip) - -LBB36_19: - LONG $0x0001bc41; WORD $0x0000 // movl $1, %r12d - WORD $0xf883; BYTE $0x0a // cmpl $10, %eax - LONG $0x0030820f; WORD $0x0000 // jb LBB36_23, $48(%rip) - LONG $0x0002bc41; WORD $0x0000 // movl $2, %r12d - WORD $0xf883; BYTE $0x64 // cmpl $100, %eax - LONG $0x0021820f; WORD $0x0000 // jb LBB36_23, $33(%rip) - LONG $0x0003bc41; WORD $0x0000 // movl $3, %r12d - LONG $0x0003e83d; BYTE $0x00 // cmpl $1000, %eax - LONG $0x0010820f; WORD $0x0000 // jb LBB36_23, $16(%rip) - WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d - LONG $0x0027103d; BYTE $0x00 // cmpl $10000, %eax - LONG $0xc4920f41 // setb %r12b - LONG $0x05f48341 // xorl $5, %r12d - -LBB36_23: - LONG $0x1c148d47 // leal (%r12,%r11), %r10d - LONG $0x1c0c8d43 // leal (%r12,%r11), %ecx - WORD $0xc183; BYTE $0xea // addl $-22, %ecx - WORD $0xf983; BYTE $0xe4 // cmpl $-28, %ecx - LONG $0x0077870f; WORD $0x0000 // ja LBB36_27, $119(%rip) - WORD $0x8944; BYTE $0xe1 // movl %r12d, %ecx - LONG $0x0f148d49 // leaq (%r15,%rcx), %rdx - WORD $0xff48; BYTE $0xc2 // incq %rdx - LONG $0x0027103d; BYTE $0x00 // cmpl $10000, %eax - LONG $0x00f3820f; WORD $0x0000 // jb LBB36_31, $243(%rip) - WORD $0xc789 // movl %eax, %edi - LONG $0xb71759be; BYTE $0xd1 // movl $3518437209, %esi - LONG $0xf7af0f48 // imulq %rdi, %rsi - LONG $0x2deec148 // shrq $45, %rsi - LONG $0xf0c66944; WORD $0xffd8; BYTE $0xff // imull $-10000, %esi, %r8d - WORD $0x0141; BYTE $0xc0 // addl %eax, %r8d - LONG $0x0464840f; WORD $0x0000 // je LBB36_59, $1124(%rip) - WORD $0x8944; BYTE $0xc0 // movl %r8d, %eax - LONG $0x1fc06948; WORD $0xeb85; BYTE $0x51 // imulq $1374389535, %rax, %rax - LONG $0x25e8c148 // shrq $37, %rax - WORD $0xf86b; BYTE $0x64 // imull $100, %eax, %edi - WORD $0x2941; BYTE $0xf8 // subl %edi, %r8d - LONG $0x443d8d48; WORD $0x0043; BYTE $0x00 // leaq $17220(%rip), %rdi /* _Digits(%rip) */ - LONG $0x1cb70f42; BYTE $0x47 // movzwl (%rdi,%r8,2), %ebx - LONG $0xfe5a8966 // movw %bx, $-2(%rdx) - LONG $0x4704b70f // movzwl (%rdi,%rax,2), %eax - LONG $0xfc428966 // movw %ax, $-4(%rdx) - WORD $0x3145; BYTE $0xc0 // xorl %r8d, %r8d - LONG $0xfcc28348 // addq $-4, %rdx - WORD $0xfe83; BYTE $0x64 // cmpl $100, %esi - LONG $0x00a6830f; WORD $0x0000 // jae LBB36_61, $166(%rip) + WORD $0x2041; BYTE $0xca // andb %cl, %r10b + LONG $0xeab60f45 // movzbl %r10b, %r13d + +LBB31_10: + WORD $0x0141; BYTE $0xc5 // addl %eax, %r13d + LONG $0xa0fd8141; WORD $0x0186; BYTE $0x00 // cmpl $100000, %r13d + LONG $0x0059820f; WORD $0x0000 // jb LBB31_17, $89(%rip) + +LBB31_13: + LONG $0x000006be; BYTE $0x00 // movl $6, %esi + LONG $0x40fd8141; WORD $0x0f42; BYTE $0x00 // cmpl $1000000, %r13d + LONG $0x0086820f; WORD $0x0000 // jb LBB31_22, $134(%rip) + LONG $0x000007be; BYTE $0x00 // movl $7, %esi + LONG $0x80fd8141; WORD $0x9896; BYTE $0x00 // cmpl $10000000, %r13d + LONG $0x0074820f; WORD $0x0000 // jb LBB31_22, $116(%rip) + LONG $0x00fd8141; WORD $0xf5e1; BYTE $0x05 // cmpl $100000000, %r13d + LONG $0x000009be; BYTE $0x00 // movl $9, %esi + LONG $0x000060e9; BYTE $0x00 // jmp LBB31_21, $96(%rip) + +LBB31_11: + LONG $0x3000c641 // movb $48, (%r8) + WORD $0x2941; BYTE $0xf8 // subl %edi, %r8d + WORD $0xff41; BYTE $0xc0 // incl %r8d + LONG $0x000af9e9; BYTE $0x00 // jmp LBB31_137, $2809(%rip) + +LBB31_12: + WORD $0xd139 // cmpl %edx, %ecx + WORD $0xd883; BYTE $0xff // sbbl $-1, %eax + WORD $0x8941; BYTE $0xc5 // movl %eax, %r13d + LONG $0xa0fd8141; WORD $0x0186; BYTE $0x00 // cmpl $100000, %r13d + LONG $0xffa7830f; WORD $0xffff // jae LBB31_13, $-89(%rip) + +LBB31_17: + LONG $0x000001be; BYTE $0x00 // movl $1, %esi + LONG $0x0afd8341 // cmpl $10, %r13d + LONG $0x0030820f; WORD $0x0000 // jb LBB31_22, $48(%rip) + LONG $0x000002be; BYTE $0x00 // movl $2, %esi + LONG $0x64fd8341 // cmpl $100, %r13d + LONG $0x0021820f; WORD $0x0000 // jb LBB31_22, $33(%rip) + LONG $0x000003be; BYTE $0x00 // movl $3, %esi + LONG $0xe8fd8141; WORD $0x0003; BYTE $0x00 // cmpl $1000, %r13d + LONG $0x000f820f; WORD $0x0000 // jb LBB31_22, $15(%rip) + LONG $0x10fd8141; WORD $0x0027; BYTE $0x00 // cmpl $10000, %r13d + LONG $0x000005be; BYTE $0x00 // movl $5, %esi + +LBB31_21: + WORD $0xde83; BYTE $0x00 // sbbl $0, %esi + +LBB31_22: + LONG $0x1e148d46 // leal (%rsi,%r11), %r10d + LONG $0x1e448d42; BYTE $0x05 // leal $5(%rsi,%r11), %eax + WORD $0xf883; BYTE $0x1b // cmpl $27, %eax + LONG $0x0075820f; WORD $0x0000 // jb LBB31_26, $117(%rip) + WORD $0xf089 // movl %esi, %eax + LONG $0x00748d4d; BYTE $0x01 // leaq $1(%r8,%rax), %r14 + LONG $0x10fd8141; WORD $0x0027; BYTE $0x00 // cmpl $10000, %r13d + LONG $0x00f3820f; WORD $0x0000 // jb LBB31_30, $243(%rip) + WORD $0x8944; BYTE $0xe8 // movl %r13d, %eax + LONG $0xb71759bb; BYTE $0xd1 // movl $3518437209, %ebx + LONG $0xd8af0f48 // imulq %rax, %rbx + LONG $0x2debc148 // shrq $45, %rbx + LONG $0xd8f0c369; WORD $0xffff // imull $-10000, %ebx, %eax + WORD $0x0144; BYTE $0xe8 // addl %r13d, %eax + LONG $0x048b840f; WORD $0x0000 // je LBB31_62, $1163(%rip) + WORD $0xc189 // movl %eax, %ecx + LONG $0x1fc96948; WORD $0xeb85; BYTE $0x51 // imulq $1374389535, %rcx, %rcx + LONG $0x25e9c148 // shrq $37, %rcx + WORD $0xd16b; BYTE $0x64 // imull $100, %ecx, %edx + WORD $0xd029 // subl %edx, %eax + LONG $0x32158d48; WORD $0x003f; BYTE $0x00 // leaq $16178(%rip), %rdx /* _Digits(%rip) */ + LONG $0x4204b70f // movzwl (%rdx,%rax,2), %eax + LONG $0x46894166; BYTE $0xfe // movw %ax, $-2(%r14) + LONG $0x4a04b70f // movzwl (%rdx,%rcx,2), %eax + LONG $0x46894166; BYTE $0xfc // movw %ax, $-4(%r14) + WORD $0x3145; BYTE $0xc9 // xorl %r9d, %r9d + LONG $0xfc4e8d49 // leaq $-4(%r14), %rcx + WORD $0xfb83; BYTE $0x64 // cmpl $100, %ebx + LONG $0x00ab830f; WORD $0x0000 // jae LBB31_64, $171(%rip) -LBB36_32: - WORD $0xf089 // movl %esi, %eax - LONG $0x0000dbe9; BYTE $0x00 // jmp LBB36_63, $219(%rip) +LBB31_31: + WORD $0xda89 // movl %ebx, %edx + LONG $0x0000e8e9; BYTE $0x00 // jmp LBB31_66, $232(%rip) -LBB36_27: - WORD $0x8945; BYTE $0xe0 // movl %r12d, %r8d +LBB31_26: + WORD $0x8941; BYTE $0xf4 // movl %esi, %r12d WORD $0x8545; BYTE $0xdb // testl %r11d, %r11d - LONG $0x023a880f; WORD $0x0000 // js LBB36_36, $570(%rip) - LONG $0x070c8d4b // leaq (%r15,%r8), %rcx - LONG $0x0027103d; BYTE $0x00 // cmpl $10000, %eax - LONG $0x0295820f; WORD $0x0000 // jb LBB36_41, $661(%rip) - WORD $0xc289 // movl %eax, %edx - LONG $0xb71759be; BYTE $0xd1 // movl $3518437209, %esi - LONG $0xf2af0f48 // imulq %rdx, %rsi - LONG $0x2deec148 // shrq $45, %rsi - LONG $0xd8f0d669; WORD $0xffff // imull $-10000, %esi, %edx - WORD $0xc201 // addl %eax, %edx - LONG $0x1fc26948; WORD $0xeb85; BYTE $0x51 // imulq $1374389535, %rdx, %rax - LONG $0x25e8c148 // shrq $37, %rax - WORD $0xf86b; BYTE $0x64 // imull $100, %eax, %edi - WORD $0xfa29 // subl %edi, %edx - LONG $0xd33d8d48; WORD $0x0042; BYTE $0x00 // leaq $17107(%rip), %rdi /* _Digits(%rip) */ - LONG $0x5714b70f // movzwl (%rdi,%rdx,2), %edx - LONG $0xfe518966 // movw %dx, $-2(%rcx) - LONG $0xfc518d48 // leaq $-4(%rcx), %rdx - LONG $0x4704b70f // movzwl (%rdi,%rax,2), %eax - LONG $0xfc418966 // movw %ax, $-4(%rcx) - WORD $0xf089 // movl %esi, %eax - WORD $0x8945; BYTE $0xd3 // movl %r10d, %r11d - WORD $0xf883; BYTE $0x64 // cmpl $100, %eax - LONG $0x0254830f; WORD $0x0000 // jae LBB36_42, $596(%rip) - -LBB36_30: - WORD $0xc689 // movl %eax, %esi - LONG $0x000288e9; BYTE $0x00 // jmp LBB36_44, $648(%rip) + LONG $0x021d880f; WORD $0x0000 // js LBB31_38, $541(%rip) + LONG $0x20348d4b // leaq (%r8,%r12), %rsi + LONG $0x10fd8141; WORD $0x0027; BYTE $0x00 // cmpl $10000, %r13d + LONG $0x028d820f; WORD $0x0000 // jb LBB31_43, $653(%rip) + WORD $0x8944; BYTE $0xe8 // movl %r13d, %eax + LONG $0xb71759b9; BYTE $0xd1 // movl $3518437209, %ecx + LONG $0xc8af0f48 // imulq %rax, %rcx + LONG $0x2de9c148 // shrq $45, %rcx + LONG $0xd8f0c169; WORD $0xffff // imull $-10000, %ecx, %eax + WORD $0x0144; BYTE $0xe8 // addl %r13d, %eax + LONG $0x1fd06948; WORD $0xeb85; BYTE $0x51 // imulq $1374389535, %rax, %rdx + LONG $0x25eac148 // shrq $37, %rdx + WORD $0xda6b; BYTE $0x64 // imull $100, %edx, %ebx + WORD $0xd829 // subl %ebx, %eax + LONG $0xbc1d8d48; WORD $0x003e; BYTE $0x00 // leaq $16060(%rip), %rbx /* _Digits(%rip) */ + LONG $0x4304b70f // movzwl (%rbx,%rax,2), %eax + LONG $0xfe468966 // movw %ax, $-2(%rsi) + LONG $0xfc468d48 // leaq $-4(%rsi), %rax + LONG $0x5314b70f // movzwl (%rbx,%rdx,2), %edx + LONG $0xfc568966 // movw %dx, $-4(%rsi) + WORD $0x8941; BYTE $0xcd // movl %ecx, %r13d + LONG $0x64fd8341 // cmpl $100, %r13d + LONG $0x0249830f; WORD $0x0000 // jae LBB31_44, $585(%rip) + +LBB31_29: + WORD $0x8944; BYTE $0xe9 // movl %r13d, %ecx + LONG $0x000286e9; BYTE $0x00 // jmp LBB31_46, $646(%rip) + +LBB31_16: + WORD $0x394c; BYTE $0xe6 // cmpq %r12, %rsi + LONG $0xffdd8341 // sbbl $-1, %r13d + WORD $0xff41; BYTE $0xc3 // incl %r11d + LONG $0xa0fd8141; WORD $0x0186; BYTE $0x00 // cmpl $100000, %r13d + LONG $0xfe54830f; WORD $0xffff // jae LBB31_13, $-428(%rip) + LONG $0xfffea8e9; BYTE $0xff // jmp LBB31_17, $-344(%rip) + +LBB31_30: + WORD $0x3145; BYTE $0xc9 // xorl %r9d, %r9d + WORD $0x894c; BYTE $0xf1 // movq %r14, %rcx + WORD $0x8944; BYTE $0xeb // movl %r13d, %ebx + WORD $0xfb83; BYTE $0x64 // cmpl $100, %ebx + LONG $0xff55820f; WORD $0xffff // jb LBB31_31, $-171(%rip) -LBB36_18: - WORD $0x8844; BYTE $0xc0 // movb %r8b, %al - WORD $0xd001 // addl %edx, %eax - WORD $0xff41; BYTE $0xc3 // incl %r11d - WORD $0x894d; BYTE $0xef // movq %r13, %r15 - LONG $0x0186a03d; BYTE $0x00 // cmpl $100000, %eax - LONG $0xd06d8b4c // movq $-48(%rbp), %r13 - LONG $0xfe45830f; WORD $0xffff // jae LBB36_15, $-443(%rip) - LONG $0xfffea5e9; BYTE $0xff // jmp LBB36_19, $-347(%rip) +LBB31_64: + WORD $0xff48; BYTE $0xc9 // decq %rcx + LONG $0x5b1d8d4c; WORD $0x003e; BYTE $0x00 // leaq $15963(%rip), %r11 /* _Digits(%rip) */ + QUAD $0x9090909090909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 -LBB36_31: - WORD $0x3145; BYTE $0xc0 // xorl %r8d, %r8d - WORD $0xc689 // movl %eax, %esi - WORD $0xfe83; BYTE $0x64 // cmpl $100, %esi - LONG $0xff5a820f; WORD $0xffff // jb LBB36_32, $-166(%rip) +LBB31_65: + WORD $0xda89 // movl %ebx, %edx + LONG $0x1fd26948; WORD $0xeb85; BYTE $0x51 // imulq $1374389535, %rdx, %rdx + LONG $0x25eac148 // shrq $37, %rdx + WORD $0xc26b; BYTE $0x64 // imull $100, %edx, %eax + WORD $0xde89 // movl %ebx, %esi + WORD $0xc629 // subl %eax, %esi + LONG $0x04b70f41; BYTE $0x73 // movzwl (%r11,%rsi,2), %eax + LONG $0xff418966 // movw %ax, $-1(%rcx) + LONG $0xfec18348 // addq $-2, %rcx + LONG $0x270ffb81; WORD $0x0000 // cmpl $9999, %ebx + WORD $0xd389 // movl %edx, %ebx + LONG $0xffd1870f; WORD $0xffff // ja LBB31_65, $-47(%rip) -LBB36_61: - WORD $0xff48; BYTE $0xca // decq %rdx - LONG $0x731d8d4c; WORD $0x0042; BYTE $0x00 // leaq $17011(%rip), %r11 /* _Digits(%rip) */ - WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 +LBB31_66: + LONG $0x01708d49 // leaq $1(%r8), %rsi + WORD $0xfa83; BYTE $0x0a // cmpl $10, %edx + LONG $0x001d820f; WORD $0x0000 // jb LBB31_68, $29(%rip) + WORD $0xd089 // movl %edx, %eax + LONG $0x0b0d8d48; WORD $0x003e; BYTE $0x00 // leaq $15883(%rip), %rcx /* _Digits(%rip) */ + WORD $0x148a; BYTE $0x41 // movb (%rcx,%rax,2), %dl + LONG $0x0141448a // movb $1(%rcx,%rax,2), %al + LONG $0x01508841 // movb %dl, $1(%r8) + LONG $0x02408841 // movb %al, $2(%r8) + LONG $0x000005e9; BYTE $0x00 // jmp LBB31_69, $5(%rip) + +LBB31_68: + WORD $0xc280; BYTE $0x30 // addb $48, %dl + WORD $0x1688 // movb %dl, (%rsi) + +LBB31_69: + WORD $0x294d; BYTE $0xce // subq %r9, %r14 + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 -LBB36_62: - WORD $0xf089 // movl %esi, %eax - LONG $0x1fc06948; WORD $0xeb85; BYTE $0x51 // imulq $1374389535, %rax, %rax - LONG $0x25e8c148 // shrq $37, %rax - WORD $0xf86b; BYTE $0x64 // imull $100, %eax, %edi - WORD $0xf389 // movl %esi, %ebx - WORD $0xfb29 // subl %edi, %ebx - LONG $0x3cb70f41; BYTE $0x5b // movzwl (%r11,%rbx,2), %edi - LONG $0xff7a8966 // movw %di, $-1(%rdx) - LONG $0xfec28348 // addq $-2, %rdx - LONG $0x270ffe81; WORD $0x0000 // cmpl $9999, %esi - WORD $0xc689 // movl %eax, %esi - LONG $0xffd1870f; WORD $0xffff // ja LBB36_62, $-47(%rip) - -LBB36_63: - LONG $0x01578d49 // leaq $1(%r15), %rdx - WORD $0xf883; BYTE $0x0a // cmpl $10, %eax - LONG $0x001f820f; WORD $0x0000 // jb LBB36_65, $31(%rip) - WORD $0xc689 // movl %eax, %esi - LONG $0x2b3d8d48; WORD $0x0042; BYTE $0x00 // leaq $16939(%rip), %rdi /* _Digits(%rip) */ - LONG $0x7704b60f // movzbl (%rdi,%rsi,2), %eax - LONG $0x775cb60f; BYTE $0x01 // movzbl $1(%rdi,%rsi,2), %ebx - LONG $0x01478841 // movb %al, $1(%r15) - LONG $0x025f8841 // movb %bl, $2(%r15) - LONG $0x000004e9; BYTE $0x00 // jmp LBB36_66, $4(%rip) - -LBB36_65: - WORD $0x3004 // addb $48, %al - WORD $0x0288 // movb %al, (%rdx) - -LBB36_66: - WORD $0x294d; BYTE $0xc1 // subq %r8, %r9 - WORD $0x014d; BYTE $0xe9 // addq %r13, %r9 - LONG $0x000001be; BYTE $0x00 // movl $1, %esi - WORD $0x294c; BYTE $0xc6 // subq %r8, %rsi - WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 +LBB31_70: + LONG $0xff7e8041; BYTE $0x30 // cmpb $48, $-1(%r14) + LONG $0xff768d4d // leaq $-1(%r14), %r14 + LONG $0xfff1840f; WORD $0xffff // je LBB31_70, $-15(%rip) + WORD $0x8841; BYTE $0x10 // movb %dl, (%r8) + LONG $0x01468d49 // leaq $1(%r14), %rax + WORD $0x8948; BYTE $0xc1 // movq %rax, %rcx + WORD $0x2948; BYTE $0xf1 // subq %rsi, %rcx + LONG $0x02f98348 // cmpq $2, %rcx + LONG $0x00068c0f; WORD $0x0000 // jl LBB31_73, $6(%rip) + WORD $0x06c6; BYTE $0x2e // movb $46, (%rsi) + WORD $0x8949; BYTE $0xc6 // movq %rax, %r14 -LBB36_67: - WORD $0xff48; BYTE $0xce // decq %rsi - LONG $0x093c8041; BYTE $0x30 // cmpb $48, (%r9,%rcx) - LONG $0xff498d4d // leaq $-1(%r9), %r9 - LONG $0xffee840f; WORD $0xffff // je LBB36_67, $-18(%rip) - WORD $0x8841; BYTE $0x07 // movb %al, (%r15) - WORD $0x0148; BYTE $0xce // addq %rcx, %rsi - LONG $0x02fe8348 // cmpq $2, %rsi - LONG $0x00458c0f; WORD $0x0000 // jl LBB36_72, $69(%rip) - LONG $0x09048d49 // leaq (%r9,%rcx), %rax - LONG $0x02c08348 // addq $2, %rax - WORD $0x02c6; BYTE $0x2e // movb $46, (%rdx) - WORD $0x00c6; BYTE $0x65 // movb $101, (%rax) +LBB31_73: + LONG $0x6506c641 // movb $101, (%r14) + LONG $0xff428d41 // leal $-1(%r10), %eax WORD $0x8545; BYTE $0xd2 // testl %r10d, %r10d - LONG $0x00418e0f; WORD $0x0000 // jle LBB36_73, $65(%rip) + LONG $0x01228e0f; WORD $0x0000 // jle LBB31_76, $290(%rip) + LONG $0x0146c641; BYTE $0x2b // movb $43, $1(%r14) + WORD $0xf883; BYTE $0x0a // cmpl $10, %eax + LONG $0x01248c0f; WORD $0x0000 // jl LBB31_77, $292(%rip) -LBB36_70: - WORD $0xff41; BYTE $0xca // decl %r10d - LONG $0x2b0140c6 // movb $43, $1(%rax) - WORD $0x8944; BYTE $0xd1 // movl %r10d, %ecx - WORD $0xf983; BYTE $0x0a // cmpl $10, %ecx - LONG $0x0043820f; WORD $0x0000 // jb LBB36_74, $67(%rip) - -LBB36_71: - WORD $0x6348; BYTE $0xc9 // movslq %ecx, %rcx - LONG $0xaa158d48; WORD $0x0041; BYTE $0x00 // leaq $16810(%rip), %rdx /* _Digits(%rip) */ - LONG $0x4a0cb70f // movzwl (%rdx,%rcx,2), %ecx - LONG $0x02488966 // movw %cx, $2(%rax) - LONG $0x04c08348 // addq $4, %rax - LONG $0x00097ae9; BYTE $0x00 // jmp LBB36_92, $2426(%rip) +LBB31_75: + WORD $0x9848 // cltq + LONG $0x8c0d8d48; WORD $0x003d; BYTE $0x00 // leaq $15756(%rip), %rcx /* _Digits(%rip) */ + LONG $0x4104b70f // movzwl (%rcx,%rax,2), %eax + LONG $0x46894166; BYTE $0x02 // movw %ax, $2(%r14) + LONG $0x04c68349 // addq $4, %r14 + WORD $0x894d; BYTE $0xf0 // movq %r14, %r8 + LONG $0x000889e9; BYTE $0x00 // jmp LBB31_136, $2185(%rip) -LBB36_72: - LONG $0x09048d49 // leaq (%r9,%rcx), %rax - WORD $0xff48; BYTE $0xc0 // incq %rax - WORD $0x00c6; BYTE $0x65 // movb $101, (%rax) - WORD $0x8545; BYTE $0xd2 // testl %r10d, %r10d - LONG $0xffbf8f0f; WORD $0xffff // jg LBB36_70, $-65(%rip) - -LBB36_73: - LONG $0x2d0140c6 // movb $45, $1(%rax) - LONG $0x000001b9; BYTE $0x00 // movl $1, %ecx - WORD $0x2944; BYTE $0xd1 // subl %r10d, %ecx - WORD $0xf983; BYTE $0x0a // cmpl $10, %ecx - LONG $0xffbd830f; WORD $0xffff // jae LBB36_71, $-67(%rip) - -LBB36_74: - WORD $0xc180; BYTE $0x30 // addb $48, %cl - WORD $0x4888; BYTE $0x02 // movb %cl, $2(%rax) - LONG $0x03c08348 // addq $3, %rax - LONG $0x000943e9; BYTE $0x00 // jmp LBB36_92, $2371(%rip) - -LBB36_33: - WORD $0xd341; BYTE $0xef // shrl %cl, %r15d - LONG $0xa0ff8141; WORD $0x0186; BYTE $0x00 // cmpl $100000, %r15d - LONG $0x01a8820f; WORD $0x0000 // jb LBB36_50, $424(%rip) - LONG $0x80ff8141; WORD $0x9896; BYTE $0x00 // cmpl $10000000, %r15d - LONG $0x000008b8; BYTE $0x00 // movl $8, %eax - LONG $0x00d88348 // sbbq $0, %rax - LONG $0x40ff8141; WORD $0x0f42; BYTE $0x00 // cmpl $1000000, %r15d - LONG $0x000006b9; BYTE $0x00 // movl $6, %ecx - LONG $0xc8430f48 // cmovaeq %rax, %rcx - WORD $0x014c; BYTE $0xe9 // addq %r13, %rcx - -LBB36_35: - WORD $0x8944; BYTE $0xf8 // movl %r15d, %eax +LBB31_32: + WORD $0xeed3 // shrl %cl, %esi + LONG $0x86a0fe81; WORD $0x0001 // cmpl $100000, %esi + LONG $0x01f1820f; WORD $0x0000 // jb LBB31_52, $497(%rip) + LONG $0x000006b8; BYTE $0x00 // movl $6, %eax + LONG $0x4240fe81; WORD $0x000f // cmpl $1000000, %esi + LONG $0x0020820f; WORD $0x0000 // jb LBB31_36, $32(%rip) + LONG $0x000007b8; BYTE $0x00 // movl $7, %eax + LONG $0x9680fe81; WORD $0x0098 // cmpl $10000000, %esi + LONG $0x000f820f; WORD $0x0000 // jb LBB31_36, $15(%rip) + LONG $0xe100fe81; WORD $0x05f5 // cmpl $100000000, %esi + LONG $0x000009b8; BYTE $0x00 // movl $9, %eax + LONG $0x00d88348 // sbbq $0, %rax + +LBB31_36: + WORD $0x014c; BYTE $0xc0 // addq %r8, %rax + +LBB31_37: + WORD $0xf189 // movl %esi, %ecx LONG $0xb71759ba; BYTE $0xd1 // movl $3518437209, %edx - LONG $0xd0af0f48 // imulq %rax, %rdx + LONG $0xd1af0f48 // imulq %rcx, %rdx LONG $0x2deac148 // shrq $45, %rdx - LONG $0xd8f0c269; WORD $0xffff // imull $-10000, %edx, %eax - WORD $0x0144; BYTE $0xf8 // addl %r15d, %eax - LONG $0x1ff06948; WORD $0xeb85; BYTE $0x51 // imulq $1374389535, %rax, %rsi + LONG $0xd8f0ca69; WORD $0xffff // imull $-10000, %edx, %ecx + WORD $0xf101 // addl %esi, %ecx + LONG $0x1ff16948; WORD $0xeb85; BYTE $0x51 // imulq $1374389535, %rcx, %rsi LONG $0x25eec148 // shrq $37, %rsi WORD $0xde6b; BYTE $0x64 // imull $100, %esi, %ebx - WORD $0xd829 // subl %ebx, %eax - LONG $0xff1d8d48; WORD $0x0040; BYTE $0x00 // leaq $16639(%rip), %rbx /* _Digits(%rip) */ - LONG $0x4304b70f // movzwl (%rbx,%rax,2), %eax - LONG $0xfe418966 // movw %ax, $-2(%rcx) - LONG $0x7304b70f // movzwl (%rbx,%rsi,2), %eax - LONG $0xfc418966 // movw %ax, $-4(%rcx) - WORD $0x8948; BYTE $0xc8 // movq %rcx, %rax - LONG $0xfcc18348 // addq $-4, %rcx - WORD $0x8941; BYTE $0xd7 // movl %edx, %r15d - LONG $0x64ff8341 // cmpl $100, %r15d - LONG $0x0171830f; WORD $0x0000 // jae LBB36_54, $369(%rip) - LONG $0x0001a8e9; BYTE $0x00 // jmp LBB36_56, $424(%rip) - -LBB36_36: - WORD $0x8545; BYTE $0xd2 // testl %r10d, %r10d - LONG $0x04dc8f0f; WORD $0x0000 // jg LBB36_102, $1244(%rip) - LONG $0x07c74166; WORD $0x2e30 // movw $11824, (%r15) - LONG $0x02c78349 // addq $2, %r15 - WORD $0x8545; BYTE $0xd2 // testl %r10d, %r10d - LONG $0x04c9890f; WORD $0x0000 // jns LBB36_102, $1225(%rip) - WORD $0x8945; BYTE $0xe6 // movl %r12d, %r14d - WORD $0xf741; BYTE $0xd6 // notl %r14d - WORD $0x2945; BYTE $0xde // subl %r11d, %r14d - WORD $0xc931 // xorl %ecx, %ecx - LONG $0x7ffe8341 // cmpl $127, %r14d - LONG $0x049d820f; WORD $0x0000 // jb LBB36_100, $1181(%rip) - WORD $0x894c; BYTE $0xfb // movq %r15, %rbx - WORD $0x894c; BYTE $0xef // movq %r13, %rdi - WORD $0xff49; BYTE $0xc6 // incq %r14 - WORD $0x894c; BYTE $0xf1 // movq %r14, %rcx - LONG $0x80e18348 // andq $-128, %rcx - LONG $0x80518d48 // leaq $-128(%rcx), %rdx - WORD $0x8949; BYTE $0xd5 // movq %rdx, %r13 - LONG $0x07edc149 // shrq $7, %r13 - WORD $0xff49; BYTE $0xc5 // incq %r13 - WORD $0x8945; BYTE $0xef // movl %r13d, %r15d - LONG $0x03e78341 // andl $3, %r15d - LONG $0x80fa8148; WORD $0x0001; BYTE $0x00 // cmpq $384, %rdx - LONG $0x036a830f; WORD $0x0000 // jae LBB36_94, $874(%rip) - WORD $0xd231 // xorl %edx, %edx - LONG $0x00040de9; BYTE $0x00 // jmp LBB36_96, $1037(%rip) - -LBB36_41: - WORD $0x8948; BYTE $0xca // movq %rcx, %rdx - WORD $0x8945; BYTE $0xd3 // movl %r10d, %r11d - WORD $0xf883; BYTE $0x64 // cmpl $100, %eax - LONG $0xfdac820f; WORD $0xffff // jb LBB36_30, $-596(%rip) - -LBB36_42: - WORD $0xff48; BYTE $0xca // decq %rdx - LONG $0x53358d4c; WORD $0x0040; BYTE $0x00 // leaq $16467(%rip), %r14 /* _Digits(%rip) */ - WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 - -LBB36_43: - WORD $0xc689 // movl %eax, %esi - LONG $0x1ff66948; WORD $0xeb85; BYTE $0x51 // imulq $1374389535, %rsi, %rsi - LONG $0x25eec148 // shrq $37, %rsi - WORD $0xfe6b; BYTE $0x64 // imull $100, %esi, %edi - WORD $0xc389 // movl %eax, %ebx - WORD $0xfb29 // subl %edi, %ebx - LONG $0x3cb70f41; BYTE $0x5e // movzwl (%r14,%rbx,2), %edi - LONG $0xff7a8966 // movw %di, $-1(%rdx) - LONG $0xfec28348 // addq $-2, %rdx - LONG $0x00270f3d; BYTE $0x00 // cmpl $9999, %eax - WORD $0xf089 // movl %esi, %eax - LONG $0xffd2870f; WORD $0xffff // ja LBB36_43, $-46(%rip) + WORD $0xd929 // subl %ebx, %ecx + LONG $0x071d8d48; WORD $0x003d; BYTE $0x00 // leaq $15623(%rip), %rbx /* _Digits(%rip) */ + LONG $0x4b0cb70f // movzwl (%rbx,%rcx,2), %ecx + LONG $0xfe488966 // movw %cx, $-2(%rax) + LONG $0x730cb70f // movzwl (%rbx,%rsi,2), %ecx + LONG $0xfc488966 // movw %cx, $-4(%rax) + WORD $0x8949; BYTE $0xc1 // movq %rax, %r9 + LONG $0xfcc08348 // addq $-4, %rax + WORD $0xd689 // movl %edx, %esi + WORD $0xfe83; BYTE $0x64 // cmpl $100, %esi + LONG $0x01ac830f; WORD $0x0000 // jae LBB31_56, $428(%rip) + LONG $0x0001efe9; BYTE $0x00 // jmp LBB31_58, $495(%rip) -LBB36_44: - WORD $0xfe83; BYTE $0x0a // cmpl $10, %esi - LONG $0x0022820f; WORD $0x0000 // jb LBB36_46, $34(%rip) - WORD $0xf089 // movl %esi, %eax - LONG $0x10158d48; WORD $0x0040; BYTE $0x00 // leaq $16400(%rip), %rdx /* _Digits(%rip) */ - LONG $0x4204b70f // movzwl (%rdx,%rax,2), %eax - LONG $0x07894166 // movw %ax, (%r15) - WORD $0x014d; BYTE $0xdf // addq %r11, %r15 - WORD $0x3945; BYTE $0xd4 // cmpl %r10d, %r12d - LONG $0x0018820f; WORD $0x0000 // jb LBB36_47, $24(%rip) - LONG $0x0002e6e9; BYTE $0x00 // jmp LBB36_91, $742(%rip) - -LBB36_46: - LONG $0x30c68040 // addb $48, %sil - WORD $0x8841; BYTE $0x37 // movb %sil, (%r15) - WORD $0x014d; BYTE $0xdf // addq %r11, %r15 - WORD $0x3945; BYTE $0xd4 // cmpl %r10d, %r12d - LONG $0x02d3830f; WORD $0x0000 // jae LBB36_91, $723(%rip) - -LBB36_47: - LONG $0x29048d4b // leaq (%r9,%r13), %rax - LONG $0x00148d49 // leaq (%r8,%rax), %rdx - WORD $0xff48; BYTE $0xc2 // incq %rdx - WORD $0x0149; BYTE $0xc3 // addq %rax, %r11 - WORD $0x394c; BYTE $0xda // cmpq %r11, %rdx - LONG $0xda470f4c // cmovaq %rdx, %r11 - WORD $0x014c; BYTE $0xc0 // addq %r8, %rax - WORD $0x2949; BYTE $0xc3 // subq %rax, %r11 - LONG $0x10fb8349 // cmpq $16, %r11 - LONG $0x029f820f; WORD $0x0000 // jb LBB36_90, $671(%rip) - LONG $0x80fb8149; WORD $0x0000; BYTE $0x00 // cmpq $128, %r11 - LONG $0x00cf830f; WORD $0x0000 // jae LBB36_75, $207(%rip) - WORD $0x3145; BYTE $0xd2 // xorl %r10d, %r10d - LONG $0x000211e9; BYTE $0x00 // jmp LBB36_84, $529(%rip) +LBB31_38: + WORD $0x8545; BYTE $0xd2 // testl %r10d, %r10d + LONG $0x04878f0f; WORD $0x0000 // jg LBB31_96, $1159(%rip) + LONG $0x00c74166; WORD $0x2e30 // movw $11824, (%r8) + LONG $0x02c08349 // addq $2, %r8 + WORD $0x8545; BYTE $0xd2 // testl %r10d, %r10d + LONG $0x0474890f; WORD $0x0000 // jns LBB31_96, $1140(%rip) + WORD $0xd6f7 // notl %esi + WORD $0x2944; BYTE $0xde // subl %r11d, %esi + WORD $0x3145; BYTE $0xff // xorl %r15d, %r15d + WORD $0xfe83; BYTE $0x7f // cmpl $127, %esi + LONG $0x043e820f; WORD $0x0000 // jb LBB31_94, $1086(%rip) + WORD $0xff48; BYTE $0xc6 // incq %rsi + WORD $0x8949; BYTE $0xf7 // movq %rsi, %r15 + LONG $0x80e78349 // andq $-128, %r15 + LONG $0x80478d49 // leaq $-128(%r15), %rax + WORD $0x8949; BYTE $0xc6 // movq %rax, %r14 + LONG $0x07eec149 // shrq $7, %r14 + WORD $0xff49; BYTE $0xc6 // incq %r14 + WORD $0x8945; BYTE $0xf3 // movl %r14d, %r11d + LONG $0x03e38341 // andl $3, %r11d + LONG $0x01803d48; WORD $0x0000 // cmpq $384, %rax + LONG $0x0321830f; WORD $0x0000 // jae LBB31_88, $801(%rip) + WORD $0xdb31 // xorl %ebx, %ebx + LONG $0x0003c4e9; BYTE $0x00 // jmp LBB31_90, $964(%rip) -LBB36_50: - LONG $0x000001b8; BYTE $0x00 // movl $1, %eax - LONG $0x0aff8341 // cmpl $10, %r15d - LONG $0x0021820f; WORD $0x0000 // jb LBB36_53, $33(%rip) - LONG $0x000002b8; BYTE $0x00 // movl $2, %eax - LONG $0x64ff8341 // cmpl $100, %r15d - LONG $0x0012820f; WORD $0x0000 // jb LBB36_53, $18(%rip) - LONG $0x000003b8; BYTE $0x00 // movl $3, %eax - LONG $0xe7ff8141; WORD $0x0003; BYTE $0x00 // cmpl $999, %r15d - LONG $0x022b870f; WORD $0x0000 // ja LBB36_87, $555(%rip) - -LBB36_53: - WORD $0x014c; BYTE $0xe8 // addq %r13, %rax - WORD $0x8948; BYTE $0xc1 // movq %rax, %rcx - LONG $0x64ff8341 // cmpl $100, %r15d - LONG $0x003c820f; WORD $0x0000 // jb LBB36_56, $60(%rip) +LBB31_76: + LONG $0x0146c641; BYTE $0x2d // movb $45, $1(%r14) + WORD $0xd8f7 // negl %eax + WORD $0xf883; BYTE $0x0a // cmpl $10, %eax + LONG $0xfedc8d0f; WORD $0xffff // jge LBB31_75, $-292(%rip) -LBB36_54: - WORD $0xff48; BYTE $0xc9 // decq %rcx - LONG $0x60058d4c; WORD $0x003f; BYTE $0x00 // leaq $16224(%rip), %r8 /* _Digits(%rip) */ +LBB31_77: + WORD $0x3004 // addb $48, %al + LONG $0x02468841 // movb %al, $2(%r14) + LONG $0x03c68349 // addq $3, %r14 + WORD $0x894d; BYTE $0xf0 // movq %r14, %r8 + LONG $0x000771e9; BYTE $0x00 // jmp LBB31_136, $1905(%rip) - // .p2align 4, 0x90 -LBB36_55: - WORD $0x8944; BYTE $0xfb // movl %r15d, %ebx - WORD $0x8944; BYTE $0xfe // movl %r15d, %esi - LONG $0x1ffe694c; WORD $0xeb85; BYTE $0x51 // imulq $1374389535, %rsi, %r15 - LONG $0x25efc149 // shrq $37, %r15 - LONG $0x64f76b41 // imull $100, %r15d, %esi - WORD $0xda89 // movl %ebx, %edx - WORD $0xf229 // subl %esi, %edx - LONG $0x14b70f41; BYTE $0x50 // movzwl (%r8,%rdx,2), %edx - LONG $0xff518966 // movw %dx, $-1(%rcx) - LONG $0xfec18348 // addq $-2, %rcx - LONG $0x270ffb81; WORD $0x0000 // cmpl $9999, %ebx - LONG $0xffce870f; WORD $0xffff // ja LBB36_55, $-50(%rip) +LBB31_43: + WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax + LONG $0x64fd8341 // cmpl $100, %r13d + LONG $0xfdb7820f; WORD $0xffff // jb LBB31_29, $-585(%rip) -LBB36_56: - LONG $0x0aff8341 // cmpl $10, %r15d - LONG $0x001a820f; WORD $0x0000 // jb LBB36_58, $26(%rip) - WORD $0x8944; BYTE $0xf9 // movl %r15d, %ecx - LONG $0x1a158d48; WORD $0x003f; BYTE $0x00 // leaq $16154(%rip), %rdx /* _Digits(%rip) */ +LBB31_44: + WORD $0xff48; BYTE $0xc8 // decq %rax + LONG $0x481d8d4c; WORD $0x003c; BYTE $0x00 // leaq $15432(%rip), %r11 /* _Digits(%rip) */ + QUAD $0x9090909090909090 // .p2align 4, 0x90 + +LBB31_45: + WORD $0x8944; BYTE $0xe9 // movl %r13d, %ecx + LONG $0x1fc96948; WORD $0xeb85; BYTE $0x51 // imulq $1374389535, %rcx, %rcx + LONG $0x25e9c148 // shrq $37, %rcx + WORD $0xd96b; BYTE $0x64 // imull $100, %ecx, %ebx + WORD $0x8944; BYTE $0xea // movl %r13d, %edx + WORD $0xda29 // subl %ebx, %edx + LONG $0x14b70f41; BYTE $0x53 // movzwl (%r11,%rdx,2), %edx + LONG $0xff508966 // movw %dx, $-1(%rax) + LONG $0xfec08348 // addq $-2, %rax + LONG $0x0ffd8141; WORD $0x0027; BYTE $0x00 // cmpl $9999, %r13d + WORD $0x8941; BYTE $0xcd // movl %ecx, %r13d + LONG $0xffcd870f; WORD $0xffff // ja LBB31_45, $-51(%rip) + +LBB31_46: + WORD $0x6349; BYTE $0xc2 // movslq %r10d, %rax + WORD $0xf983; BYTE $0x0a // cmpl $10, %ecx + LONG $0x0022820f; WORD $0x0000 // jb LBB31_48, $34(%rip) + WORD $0xc989 // movl %ecx, %ecx + LONG $0xf8158d48; WORD $0x003b; BYTE $0x00 // leaq $15352(%rip), %rdx /* _Digits(%rip) */ LONG $0x4a0cb70f // movzwl (%rdx,%rcx,2), %ecx - LONG $0x4d894166; BYTE $0x00 // movw %cx, (%r13) - WORD $0xf829 // subl %edi, %eax - LONG $0x0006eee9; BYTE $0x00 // jmp LBB36_93, $1774(%rip) + LONG $0x08894166 // movw %cx, (%r8) + WORD $0x0149; BYTE $0xc0 // addq %rax, %r8 + WORD $0x3949; BYTE $0xc4 // cmpq %rax, %r12 + LONG $0x00178c0f; WORD $0x0000 // jl LBB31_49, $23(%rip) + LONG $0x0006f1e9; BYTE $0x00 // jmp LBB31_136, $1777(%rip) -LBB36_58: - LONG $0x30c78041 // addb $48, %r15b - LONG $0x007d8845 // movb %r15b, (%r13) - WORD $0xf829 // subl %edi, %eax - LONG $0x0006dfe9; BYTE $0x00 // jmp LBB36_93, $1759(%rip) +LBB31_48: + WORD $0xc180; BYTE $0x30 // addb $48, %cl + WORD $0x8841; BYTE $0x08 // movb %cl, (%r8) + WORD $0x0149; BYTE $0xc0 // addq %rax, %r8 + WORD $0x3949; BYTE $0xc4 // cmpq %rax, %r12 + LONG $0x06df8d0f; WORD $0x0000 // jge LBB31_136, $1759(%rip) + +LBB31_49: + LONG $0x21048d4b // leaq (%r9,%r12), %rax + LONG $0x075c8d4c; BYTE $0x01 // leaq $1(%rdi,%rax), %r11 + WORD $0x394d; BYTE $0xc3 // cmpq %r8, %r11 + LONG $0xd8460f4d // cmovbeq %r8, %r11 + LONG $0x0f0c8d4a // leaq (%rdi,%r9), %rcx + WORD $0x014c; BYTE $0xe1 // addq %r12, %rcx + WORD $0x2949; BYTE $0xcb // subq %rcx, %r11 + LONG $0x80fb8149; WORD $0x0000; BYTE $0x00 // cmpq $128, %r11 + LONG $0x0206820f; WORD $0x0000 // jb LBB31_85, $518(%rip) + WORD $0x894d; BYTE $0xda // movq %r11, %r10 + LONG $0x80e28349 // andq $-128, %r10 + LONG $0x804a8d49 // leaq $-128(%r10), %rcx + WORD $0x8948; BYTE $0xcb // movq %rcx, %rbx + LONG $0x07ebc148 // shrq $7, %rbx + WORD $0xff48; BYTE $0xc3 // incq %rbx + WORD $0xda89 // movl %ebx, %edx + WORD $0xe283; BYTE $0x03 // andl $3, %edx + LONG $0x80f98148; WORD $0x0001; BYTE $0x00 // cmpq $384, %rcx + LONG $0x00d7830f; WORD $0x0000 // jae LBB31_78, $215(%rip) + WORD $0xc031 // xorl %eax, %eax + LONG $0x000188e9; BYTE $0x00 // jmp LBB31_80, $392(%rip) -LBB36_59: - LONG $0x0004b841; WORD $0x0000 // movl $4, %r8d - LONG $0xfcc28348 // addq $-4, %rdx +LBB31_52: + LONG $0x0001b941; WORD $0x0000 // movl $1, %r9d + WORD $0xfe83; BYTE $0x0a // cmpl $10, %esi + LONG $0x0021820f; WORD $0x0000 // jb LBB31_55, $33(%rip) + LONG $0x0002b941; WORD $0x0000 // movl $2, %r9d WORD $0xfe83; BYTE $0x64 // cmpl $100, %esi - LONG $0xfbc5820f; WORD $0xffff // jb LBB36_32, $-1083(%rip) - LONG $0xfffc66e9; BYTE $0xff // jmp LBB36_61, $-922(%rip) + LONG $0x0012820f; WORD $0x0000 // jb LBB31_55, $18(%rip) + LONG $0x0003b941; WORD $0x0000 // movl $3, %r9d + LONG $0x03e8fe81; WORD $0x0000 // cmpl $1000, %esi + LONG $0x01bc830f; WORD $0x0000 // jae LBB31_86, $444(%rip) -LBB36_75: - WORD $0x894d; BYTE $0xda // movq %r11, %r10 - LONG $0x80e28349 // andq $-128, %r10 - LONG $0x80428d49 // leaq $-128(%r10), %rax - WORD $0x8948; BYTE $0xc2 // movq %rax, %rdx - LONG $0x07eac148 // shrq $7, %rdx - WORD $0xff48; BYTE $0xc2 // incq %rdx - WORD $0x8941; BYTE $0xd6 // movl %edx, %r14d - LONG $0x03e68341 // andl $3, %r14d - LONG $0x01803d48; WORD $0x0000 // cmpq $384, %rax - LONG $0x0007830f; WORD $0x0000 // jae LBB36_77, $7(%rip) - WORD $0xf631 // xorl %esi, %esi - LONG $0x0000b5e9; BYTE $0x00 // jmp LBB36_79, $181(%rip) - -LBB36_77: - LONG $0xfce28348 // andq $-4, %rdx - LONG $0x01048d4b // leaq (%r9,%r8), %rax - WORD $0x014c; BYTE $0xe8 // addq %r13, %rax - LONG $0x01e00548; WORD $0x0000 // addq $480, %rax - WORD $0xf631 // xorl %esi, %esi - QUAD $0xfffff849056ffdc5 // vmovdqa $-1975(%rip), %ymm0 /* LCPI36_0(%rip) */ - QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90 +LBB31_55: + WORD $0x014d; BYTE $0xc1 // addq %r8, %r9 + WORD $0x894c; BYTE $0xc8 // movq %r9, %rax + WORD $0xfe83; BYTE $0x64 // cmpl $100, %esi + LONG $0x0048820f; WORD $0x0000 // jb LBB31_58, $72(%rip) -LBB36_78: - QUAD $0xfffe2030847ffec5; BYTE $0xff // vmovdqu %ymm0, $-480(%rax,%rsi) - QUAD $0xfffe4030847ffec5; BYTE $0xff // vmovdqu %ymm0, $-448(%rax,%rsi) - QUAD $0xfffe6030847ffec5; BYTE $0xff // vmovdqu %ymm0, $-416(%rax,%rsi) - QUAD $0xfffe8030847ffec5; BYTE $0xff // vmovdqu %ymm0, $-384(%rax,%rsi) - QUAD $0xfffea030847ffec5; BYTE $0xff // vmovdqu %ymm0, $-352(%rax,%rsi) - QUAD $0xfffec030847ffec5; BYTE $0xff // vmovdqu %ymm0, $-320(%rax,%rsi) - QUAD $0xfffee030847ffec5; BYTE $0xff // vmovdqu %ymm0, $-288(%rax,%rsi) - QUAD $0xffff0030847ffec5; BYTE $0xff // vmovdqu %ymm0, $-256(%rax,%rsi) - QUAD $0xffff2030847ffec5; BYTE $0xff // vmovdqu %ymm0, $-224(%rax,%rsi) - QUAD $0xffff4030847ffec5; BYTE $0xff // vmovdqu %ymm0, $-192(%rax,%rsi) - QUAD $0xffff6030847ffec5; BYTE $0xff // vmovdqu %ymm0, $-160(%rax,%rsi) - LONG $0x447ffec5; WORD $0x8030 // vmovdqu %ymm0, $-128(%rax,%rsi) - LONG $0x447ffec5; WORD $0xa030 // vmovdqu %ymm0, $-96(%rax,%rsi) - LONG $0x447ffec5; WORD $0xc030 // vmovdqu %ymm0, $-64(%rax,%rsi) - LONG $0x447ffec5; WORD $0xe030 // vmovdqu %ymm0, $-32(%rax,%rsi) - LONG $0x047ffec5; BYTE $0x30 // vmovdqu %ymm0, (%rax,%rsi) - LONG $0x00c68148; WORD $0x0002; BYTE $0x00 // addq $512, %rsi - LONG $0xfcc28348 // addq $-4, %rdx - LONG $0xff6f850f; WORD $0xffff // jne LBB36_78, $-145(%rip) - -LBB36_79: - WORD $0x854d; BYTE $0xf6 // testq %r14, %r14 - LONG $0x004a840f; WORD $0x0000 // je LBB36_82, $74(%rip) - WORD $0x014c; BYTE $0xce // addq %r9, %rsi - WORD $0x014c; BYTE $0xc6 // addq %r8, %rsi - LONG $0x2e048d4a // leaq (%rsi,%r13), %rax - LONG $0x60c08348 // addq $96, %rax - LONG $0x07e6c149 // shlq $7, %r14 - WORD $0xd231 // xorl %edx, %edx - QUAD $0xfffff78a056ffdc5 // vmovdqa $-2166(%rip), %ymm0 /* LCPI36_0(%rip) */ - QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90 +LBB31_56: + WORD $0xff48; BYTE $0xc8 // decq %rax + LONG $0x2f158d4c; WORD $0x003b; BYTE $0x00 // leaq $15151(%rip), %r10 /* _Digits(%rip) */ + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 -LBB36_81: - LONG $0x447ffec5; WORD $0xa010 // vmovdqu %ymm0, $-96(%rax,%rdx) - LONG $0x447ffec5; WORD $0xc010 // vmovdqu %ymm0, $-64(%rax,%rdx) - LONG $0x447ffec5; WORD $0xe010 // vmovdqu %ymm0, $-32(%rax,%rdx) - LONG $0x047ffec5; BYTE $0x10 // vmovdqu %ymm0, (%rax,%rdx) - LONG $0x80ea8348 // subq $-128, %rdx - WORD $0x3949; BYTE $0xd6 // cmpq %rdx, %r14 - LONG $0xffdc850f; WORD $0xffff // jne LBB36_81, $-36(%rip) - -LBB36_82: - WORD $0x394d; BYTE $0xd3 // cmpq %r10, %r11 - LONG $0x0092840f; WORD $0x0000 // je LBB36_91, $146(%rip) - LONG $0x70c3f641 // testb $112, %r11b - LONG $0x0071840f; WORD $0x0000 // je LBB36_89, $113(%rip) - -LBB36_84: - WORD $0x894c; BYTE $0xd8 // movq %r11, %rax - LONG $0xf0e08348 // andq $-16, %rax - WORD $0x0148; BYTE $0xc1 // addq %rax, %rcx - WORD $0x014d; BYTE $0xd1 // addq %r10, %r9 - WORD $0x014d; BYTE $0xc1 // addq %r8, %r9 - WORD $0x014d; BYTE $0xe9 // addq %r13, %r9 - WORD $0x8948; BYTE $0xc2 // movq %rax, %rdx - WORD $0x294c; BYTE $0xd2 // subq %r10, %rdx - WORD $0xf631 // xorl %esi, %esi - QUAD $0xfffff746056ff9c5 // vmovdqa $-2234(%rip), %xmm0 /* LCPI36_1(%rip) */ - LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 +LBB31_57: + WORD $0xf389 // movl %esi, %ebx + WORD $0xf689 // movl %esi, %esi + LONG $0x1ff66948; WORD $0xeb85; BYTE $0x51 // imulq $1374389535, %rsi, %rsi + LONG $0x25eec148 // shrq $37, %rsi + WORD $0xce6b; BYTE $0x64 // imull $100, %esi, %ecx + WORD $0xda89 // movl %ebx, %edx + WORD $0xca29 // subl %ecx, %edx + LONG $0x0cb70f41; BYTE $0x52 // movzwl (%r10,%rdx,2), %ecx + LONG $0xff488966 // movw %cx, $-1(%rax) + LONG $0xfec08348 // addq $-2, %rax + LONG $0x270ffb81; WORD $0x0000 // cmpl $9999, %ebx + LONG $0xffd1870f; WORD $0xffff // ja LBB31_57, $-47(%rip) -LBB36_85: - LONG $0x7f7ac1c4; WORD $0x3104 // vmovdqu %xmm0, (%r9,%rsi) - LONG $0x10c68348 // addq $16, %rsi - WORD $0x3948; BYTE $0xf2 // cmpq %rsi, %rdx - LONG $0xffed850f; WORD $0xffff // jne LBB36_85, $-19(%rip) - WORD $0x3949; BYTE $0xc3 // cmpq %rax, %r11 - LONG $0x0034850f; WORD $0x0000 // jne LBB36_90, $52(%rip) - LONG $0x00003ee9; BYTE $0x00 // jmp LBB36_91, $62(%rip) - -LBB36_87: - LONG $0x10ff8141; WORD $0x0027; BYTE $0x00 // cmpl $10000, %r15d - WORD $0x894c; BYTE $0xe9 // movq %r13, %rcx - LONG $0x00d98348 // sbbq $0, %rcx - LONG $0x05c18348 // addq $5, %rcx - LONG $0x10ff8141; WORD $0x0027; BYTE $0x00 // cmpl $10000, %r15d - LONG $0xfc01830f; WORD $0xffff // jae LBB36_35, $-1023(%rip) - WORD $0x8948; BYTE $0xc8 // movq %rcx, %rax - LONG $0xfffdbee9; BYTE $0xff // jmp LBB36_54, $-578(%rip) +LBB31_58: + WORD $0xfe83; BYTE $0x0a // cmpl $10, %esi + LONG $0x0016820f; WORD $0x0000 // jb LBB31_60, $22(%rip) + WORD $0xf089 // movl %esi, %eax + LONG $0xdf0d8d48; WORD $0x003a; BYTE $0x00 // leaq $15071(%rip), %rcx /* _Digits(%rip) */ + LONG $0x4104b70f // movzwl (%rcx,%rax,2), %eax + LONG $0x00894166 // movw %ax, (%r8) + LONG $0x000007e9; BYTE $0x00 // jmp LBB31_61, $7(%rip) -LBB36_89: - WORD $0x014c; BYTE $0xd1 // addq %r10, %rcx - LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 +LBB31_60: + LONG $0x30c68040 // addb $48, %sil + WORD $0x8841; BYTE $0x30 // movb %sil, (%r8) -LBB36_90: - WORD $0x01c6; BYTE $0x30 // movb $48, (%rcx) - WORD $0xff48; BYTE $0xc1 // incq %rcx - WORD $0x394c; BYTE $0xf9 // cmpq %r15, %rcx - LONG $0xfff1820f; WORD $0xffff // jb LBB36_90, $-15(%rip) +LBB31_61: + WORD $0x2941; BYTE $0xf9 // subl %edi, %r9d + WORD $0x8945; BYTE $0xc8 // movl %r9d, %r8d + LONG $0x0005d5e9; BYTE $0x00 // jmp LBB31_137, $1493(%rip) -LBB36_91: - WORD $0x894c; BYTE $0xf8 // movq %r15, %rax - LONG $0x0004eae9; BYTE $0x00 // jmp LBB36_92, $1258(%rip) +LBB31_62: + LONG $0x0004b941; WORD $0x0000 // movl $4, %r9d + LONG $0xfc4e8d49 // leaq $-4(%r14), %rcx + WORD $0xfb83; BYTE $0x64 // cmpl $100, %ebx + LONG $0xfb9d820f; WORD $0xffff // jb LBB31_31, $-1123(%rip) + LONG $0xfffc43e9; BYTE $0xff // jmp LBB31_64, $-957(%rip) + +LBB31_78: + QUAD $0x000001e0078c8d48 // leaq $480(%rdi,%rax), %rcx + LONG $0xfce38348 // andq $-4, %rbx + WORD $0xf748; BYTE $0xdb // negq %rbx + WORD $0xc031 // xorl %eax, %eax + QUAD $0xfffff87f056ffdc5 // vmovdqa $-1921(%rip), %ymm0 /* LCPI31_0(%rip) */ + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 -LBB36_94: - LONG $0xfce58349 // andq $-4, %r13 - LONG $0x39348d49 // leaq (%r9,%rdi), %rsi - LONG $0xe2c68148; WORD $0x0001; BYTE $0x00 // addq $482, %rsi - WORD $0xd231 // xorl %edx, %edx - QUAD $0xfffff6a0056ffdc5 // vmovdqa $-2400(%rip), %ymm0 /* LCPI36_0(%rip) */ - -LBB36_95: - QUAD $0xfffe2016847ffec5; BYTE $0xff // vmovdqu %ymm0, $-480(%rsi,%rdx) - QUAD $0xfffe4016847ffec5; BYTE $0xff // vmovdqu %ymm0, $-448(%rsi,%rdx) - QUAD $0xfffe6016847ffec5; BYTE $0xff // vmovdqu %ymm0, $-416(%rsi,%rdx) - QUAD $0xfffe8016847ffec5; BYTE $0xff // vmovdqu %ymm0, $-384(%rsi,%rdx) - QUAD $0xfffea016847ffec5; BYTE $0xff // vmovdqu %ymm0, $-352(%rsi,%rdx) - QUAD $0xfffec016847ffec5; BYTE $0xff // vmovdqu %ymm0, $-320(%rsi,%rdx) - QUAD $0xfffee016847ffec5; BYTE $0xff // vmovdqu %ymm0, $-288(%rsi,%rdx) - QUAD $0xffff0016847ffec5; BYTE $0xff // vmovdqu %ymm0, $-256(%rsi,%rdx) - QUAD $0xffff2016847ffec5; BYTE $0xff // vmovdqu %ymm0, $-224(%rsi,%rdx) - QUAD $0xffff4016847ffec5; BYTE $0xff // vmovdqu %ymm0, $-192(%rsi,%rdx) - QUAD $0xffff6016847ffec5; BYTE $0xff // vmovdqu %ymm0, $-160(%rsi,%rdx) - LONG $0x447ffec5; WORD $0x8016 // vmovdqu %ymm0, $-128(%rsi,%rdx) - LONG $0x447ffec5; WORD $0xa016 // vmovdqu %ymm0, $-96(%rsi,%rdx) - LONG $0x447ffec5; WORD $0xc016 // vmovdqu %ymm0, $-64(%rsi,%rdx) - LONG $0x447ffec5; WORD $0xe016 // vmovdqu %ymm0, $-32(%rsi,%rdx) - LONG $0x047ffec5; BYTE $0x16 // vmovdqu %ymm0, (%rsi,%rdx) - LONG $0x00c28148; WORD $0x0002; BYTE $0x00 // addq $512, %rdx - LONG $0xfcc58349 // addq $-4, %r13 - LONG $0xff6f850f; WORD $0xffff // jne LBB36_95, $-145(%rip) +LBB31_79: + QUAD $0xfffe2001847ffec5; BYTE $0xff // vmovdqu %ymm0, $-480(%rcx,%rax) + QUAD $0xfffe4001847ffec5; BYTE $0xff // vmovdqu %ymm0, $-448(%rcx,%rax) + QUAD $0xfffe6001847ffec5; BYTE $0xff // vmovdqu %ymm0, $-416(%rcx,%rax) + QUAD $0xfffe8001847ffec5; BYTE $0xff // vmovdqu %ymm0, $-384(%rcx,%rax) + QUAD $0xfffea001847ffec5; BYTE $0xff // vmovdqu %ymm0, $-352(%rcx,%rax) + QUAD $0xfffec001847ffec5; BYTE $0xff // vmovdqu %ymm0, $-320(%rcx,%rax) + QUAD $0xfffee001847ffec5; BYTE $0xff // vmovdqu %ymm0, $-288(%rcx,%rax) + QUAD $0xffff0001847ffec5; BYTE $0xff // vmovdqu %ymm0, $-256(%rcx,%rax) + QUAD $0xffff2001847ffec5; BYTE $0xff // vmovdqu %ymm0, $-224(%rcx,%rax) + QUAD $0xffff4001847ffec5; BYTE $0xff // vmovdqu %ymm0, $-192(%rcx,%rax) + QUAD $0xffff6001847ffec5; BYTE $0xff // vmovdqu %ymm0, $-160(%rcx,%rax) + LONG $0x447ffec5; WORD $0x8001 // vmovdqu %ymm0, $-128(%rcx,%rax) + LONG $0x447ffec5; WORD $0xa001 // vmovdqu %ymm0, $-96(%rcx,%rax) + LONG $0x447ffec5; WORD $0xc001 // vmovdqu %ymm0, $-64(%rcx,%rax) + LONG $0x447ffec5; WORD $0xe001 // vmovdqu %ymm0, $-32(%rcx,%rax) + LONG $0x047ffec5; BYTE $0x01 // vmovdqu %ymm0, (%rcx,%rax) + LONG $0x02000548; WORD $0x0000 // addq $512, %rax + LONG $0x04c38348 // addq $4, %rbx + LONG $0xff70850f; WORD $0xffff // jne LBB31_79, $-144(%rip) + +LBB31_80: + WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx + LONG $0x0037840f; WORD $0x0000 // je LBB31_83, $55(%rip) + WORD $0x014c; BYTE $0xc8 // addq %r9, %rax + WORD $0x014c; BYTE $0xe0 // addq %r12, %rax + LONG $0x07448d48; BYTE $0x60 // leaq $96(%rdi,%rax), %rax + WORD $0xf748; BYTE $0xda // negq %rdx + QUAD $0xfffff7c1056ffdc5 // vmovdqa $-2111(%rip), %ymm0 /* LCPI31_0(%rip) */ + BYTE $0x90 // .p2align 4, 0x90 -LBB36_96: - WORD $0x854d; BYTE $0xff // testq %r15, %r15 - WORD $0x8949; BYTE $0xfd // movq %rdi, %r13 - LONG $0x003c840f; WORD $0x0000 // je LBB36_99, $60(%rip) - WORD $0x014c; BYTE $0xca // addq %r9, %rdx - WORD $0x014c; BYTE $0xea // addq %r13, %rdx - LONG $0x62c28348 // addq $98, %rdx - LONG $0x07e7c149 // shlq $7, %r15 - WORD $0xf631 // xorl %esi, %esi - QUAD $0xfffff5eb056ffdc5 // vmovdqa $-2581(%rip), %ymm0 /* LCPI36_0(%rip) */ +LBB31_82: + LONG $0x407ffec5; BYTE $0xa0 // vmovdqu %ymm0, $-96(%rax) + LONG $0x407ffec5; BYTE $0xc0 // vmovdqu %ymm0, $-64(%rax) + LONG $0x407ffec5; BYTE $0xe0 // vmovdqu %ymm0, $-32(%rax) + LONG $0x007ffec5 // vmovdqu %ymm0, (%rax) + LONG $0x80e88348 // subq $-128, %rax + WORD $0xff48; BYTE $0xc2 // incq %rdx + LONG $0xffe0850f; WORD $0xffff // jne LBB31_82, $-32(%rip) -LBB36_98: - LONG $0x447ffec5; WORD $0xa032 // vmovdqu %ymm0, $-96(%rdx,%rsi) - LONG $0x447ffec5; WORD $0xc032 // vmovdqu %ymm0, $-64(%rdx,%rsi) - LONG $0x447ffec5; WORD $0xe032 // vmovdqu %ymm0, $-32(%rdx,%rsi) - LONG $0x047ffec5; BYTE $0x32 // vmovdqu %ymm0, (%rdx,%rsi) - LONG $0x80ee8348 // subq $-128, %rsi - WORD $0x3949; BYTE $0xf7 // cmpq %rsi, %r15 - LONG $0xffdc850f; WORD $0xffff // jne LBB36_98, $-36(%rip) +LBB31_83: + WORD $0x394d; BYTE $0xda // cmpq %r11, %r10 + LONG $0x04b9840f; WORD $0x0000 // je LBB31_136, $1209(%rip) + WORD $0x014c; BYTE $0xd6 // addq %r10, %rsi + LONG $0x90909090 // .p2align 4, 0x90 -LBB36_99: - WORD $0x8949; BYTE $0xdf // movq %rbx, %r15 - WORD $0x0149; BYTE $0xcf // addq %rcx, %r15 - WORD $0x3949; BYTE $0xce // cmpq %rcx, %r14 - LONG $0x0017840f; WORD $0x0000 // je LBB36_102, $23(%rip) +LBB31_85: + WORD $0x06c6; BYTE $0x30 // movb $48, (%rsi) + WORD $0xff48; BYTE $0xc6 // incq %rsi + WORD $0x394c; BYTE $0xc6 // cmpq %r8, %rsi + LONG $0xfff1820f; WORD $0xffff // jb LBB31_85, $-15(%rip) + LONG $0x00049ee9; BYTE $0x00 // jmp LBB31_136, $1182(%rip) -LBB36_100: - WORD $0x0144; BYTE $0xd1 // addl %r10d, %ecx - WORD $0xd9f7 // negl %ecx - WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 +LBB31_86: + LONG $0x2710fe81; WORD $0x0000 // cmpl $10000, %esi + WORD $0x894c; BYTE $0xc0 // movq %r8, %rax + LONG $0x00d88348 // sbbq $0, %rax + LONG $0x05c08348 // addq $5, %rax + LONG $0x2710fe81; WORD $0x0000 // cmpl $10000, %esi + LONG $0xfc3a830f; WORD $0xffff // jae LBB31_37, $-966(%rip) + WORD $0x8949; BYTE $0xc1 // movq %rax, %r9 + LONG $0xfffe2ee9; BYTE $0xff // jmp LBB31_56, $-466(%rip) -LBB36_101: - LONG $0x3007c641 // movb $48, (%r15) - WORD $0xff49; BYTE $0xc7 // incq %r15 - WORD $0xc9ff // decl %ecx - LONG $0xfff1850f; WORD $0xffff // jne LBB36_101, $-15(%rip) +LBB31_88: + QUAD $0x000001e239848d49 // leaq $482(%r9,%rdi), %rax + LONG $0xfce68349 // andq $-4, %r14 + WORD $0xf749; BYTE $0xde // negq %r14 + WORD $0xdb31 // xorl %ebx, %ebx + QUAD $0xfffff73e056ffdc5 // vmovdqa $-2242(%rip), %ymm0 /* LCPI31_0(%rip) */ + +LBB31_89: + QUAD $0xfffe2018847ffec5; BYTE $0xff // vmovdqu %ymm0, $-480(%rax,%rbx) + QUAD $0xfffe4018847ffec5; BYTE $0xff // vmovdqu %ymm0, $-448(%rax,%rbx) + QUAD $0xfffe6018847ffec5; BYTE $0xff // vmovdqu %ymm0, $-416(%rax,%rbx) + QUAD $0xfffe8018847ffec5; BYTE $0xff // vmovdqu %ymm0, $-384(%rax,%rbx) + QUAD $0xfffea018847ffec5; BYTE $0xff // vmovdqu %ymm0, $-352(%rax,%rbx) + QUAD $0xfffec018847ffec5; BYTE $0xff // vmovdqu %ymm0, $-320(%rax,%rbx) + QUAD $0xfffee018847ffec5; BYTE $0xff // vmovdqu %ymm0, $-288(%rax,%rbx) + QUAD $0xffff0018847ffec5; BYTE $0xff // vmovdqu %ymm0, $-256(%rax,%rbx) + QUAD $0xffff2018847ffec5; BYTE $0xff // vmovdqu %ymm0, $-224(%rax,%rbx) + QUAD $0xffff4018847ffec5; BYTE $0xff // vmovdqu %ymm0, $-192(%rax,%rbx) + QUAD $0xffff6018847ffec5; BYTE $0xff // vmovdqu %ymm0, $-160(%rax,%rbx) + LONG $0x447ffec5; WORD $0x8018 // vmovdqu %ymm0, $-128(%rax,%rbx) + LONG $0x447ffec5; WORD $0xa018 // vmovdqu %ymm0, $-96(%rax,%rbx) + LONG $0x447ffec5; WORD $0xc018 // vmovdqu %ymm0, $-64(%rax,%rbx) + LONG $0x447ffec5; WORD $0xe018 // vmovdqu %ymm0, $-32(%rax,%rbx) + LONG $0x047ffec5; BYTE $0x18 // vmovdqu %ymm0, (%rax,%rbx) + LONG $0x00c38148; WORD $0x0002; BYTE $0x00 // addq $512, %rbx + LONG $0x04c68349 // addq $4, %r14 + LONG $0xff6f850f; WORD $0xffff // jne LBB31_89, $-145(%rip) -LBB36_102: - LONG $0xd07d894c // movq %r15, $-48(%rbp) - WORD $0x014d; BYTE $0xc7 // addq %r8, %r15 - LONG $0x0027103d; BYTE $0x00 // cmpl $10000, %eax - LONG $0x005f820f; WORD $0x0000 // jb LBB36_105, $95(%rip) - WORD $0xc289 // movl %eax, %edx - LONG $0xb71759bb; BYTE $0xd1 // movl $3518437209, %ebx - LONG $0xdaaf0f48 // imulq %rdx, %rbx - LONG $0x2debc148 // shrq $45, %rbx - LONG $0xd8f0d369; WORD $0xffff // imull $-10000, %ebx, %edx - WORD $0xc201 // addl %eax, %edx - LONG $0x01c3840f; WORD $0x0000 // je LBB36_107, $451(%rip) - WORD $0xd089 // movl %edx, %eax - LONG $0x1fc06948; WORD $0xeb85; BYTE $0x51 // imulq $1374389535, %rax, %rax - LONG $0x25e8c148 // shrq $37, %rax - WORD $0xf06b; BYTE $0x64 // imull $100, %eax, %esi - WORD $0xf229 // subl %esi, %edx - LONG $0xa9358d48; WORD $0x003b; BYTE $0x00 // leaq $15273(%rip), %rsi /* _Digits(%rip) */ - LONG $0x5614b70f // movzwl (%rsi,%rdx,2), %edx - LONG $0x57894166; BYTE $0xfe // movw %dx, $-2(%r15) - LONG $0x4604b70f // movzwl (%rsi,%rax,2), %eax - LONG $0x47894166; BYTE $0xfc // movw %ax, $-4(%r15) - WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d - LONG $0xfc578d49 // leaq $-4(%r15), %rdx - WORD $0xfb83; BYTE $0x64 // cmpl $100, %ebx - LONG $0x0018830f; WORD $0x0000 // jae LBB36_109, $24(%rip) +LBB31_90: + WORD $0x854d; BYTE $0xdb // testq %r11, %r11 + LONG $0x0033840f; WORD $0x0000 // je LBB31_93, $51(%rip) + WORD $0x014c; BYTE $0xcb // addq %r9, %rbx + LONG $0x1f448d48; BYTE $0x62 // leaq $98(%rdi,%rbx), %rax + WORD $0xf749; BYTE $0xdb // negq %r11 + QUAD $0xfffff691056ffdc5 // vmovdqa $-2415(%rip), %ymm0 /* LCPI31_0(%rip) */ + +LBB31_92: + LONG $0x407ffec5; BYTE $0xa0 // vmovdqu %ymm0, $-96(%rax) + LONG $0x407ffec5; BYTE $0xc0 // vmovdqu %ymm0, $-64(%rax) + LONG $0x407ffec5; BYTE $0xe0 // vmovdqu %ymm0, $-32(%rax) + LONG $0x007ffec5 // vmovdqu %ymm0, (%rax) + LONG $0x80e88348 // subq $-128, %rax + WORD $0xff49; BYTE $0xc3 // incq %r11 + LONG $0xffe0850f; WORD $0xffff // jne LBB31_92, $-32(%rip) + +LBB31_93: + WORD $0x014d; BYTE $0xf8 // addq %r15, %r8 + WORD $0x394c; BYTE $0xfe // cmpq %r15, %rsi + LONG $0x0025840f; WORD $0x0000 // je LBB31_96, $37(%rip) + +LBB31_94: + WORD $0x0145; BYTE $0xd7 // addl %r10d, %r15d + WORD $0xf741; BYTE $0xdf // negl %r15d + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 -LBB36_106: - WORD $0xd889 // movl %ebx, %eax - LONG $0x00004ee9; BYTE $0x00 // jmp LBB36_111, $78(%rip) +LBB31_95: + LONG $0x3000c641 // movb $48, (%r8) + WORD $0xff49; BYTE $0xc0 // incq %r8 + WORD $0xff41; BYTE $0xcf // decl %r15d + LONG $0xfff0850f; WORD $0xffff // jne LBB31_95, $-16(%rip) + +LBB31_96: + LONG $0x20048d4b // leaq (%r8,%r12), %rax + LONG $0x10fd8141; WORD $0x0027; BYTE $0x00 // cmpl $10000, %r13d + LONG $0x0063820f; WORD $0x0000 // jb LBB31_99, $99(%rip) + WORD $0x8944; BYTE $0xe9 // movl %r13d, %ecx + LONG $0x1759bb41; WORD $0xd1b7 // movl $3518437209, %r11d + LONG $0xd9af0f4c // imulq %rcx, %r11 + LONG $0x2debc149 // shrq $45, %r11 + LONG $0xf0cb6941; WORD $0xffd8; BYTE $0xff // imull $-10000, %r11d, %ecx + WORD $0x0144; BYTE $0xe9 // addl %r13d, %ecx + LONG $0x0190840f; WORD $0x0000 // je LBB31_101, $400(%rip) + WORD $0xca89 // movl %ecx, %edx + LONG $0x1fd26948; WORD $0xeb85; BYTE $0x51 // imulq $1374389535, %rdx, %rdx + LONG $0x25eac148 // shrq $37, %rdx + WORD $0xda6b; BYTE $0x64 // imull $100, %edx, %ebx + WORD $0xd929 // subl %ebx, %ecx + LONG $0x051d8d48; WORD $0x0038; BYTE $0x00 // leaq $14341(%rip), %rbx /* _Digits(%rip) */ + LONG $0x4b0cb70f // movzwl (%rbx,%rcx,2), %ecx + LONG $0xfe488966 // movw %cx, $-2(%rax) + LONG $0x530cb70f // movzwl (%rbx,%rdx,2), %ecx + LONG $0xfc488966 // movw %cx, $-4(%rax) + WORD $0x3145; BYTE $0xc9 // xorl %r9d, %r9d + LONG $0xfcc08348 // addq $-4, %rax + LONG $0x64fb8341 // cmpl $100, %r11d + LONG $0x0018830f; WORD $0x0000 // jae LBB31_103, $24(%rip) -LBB36_105: - WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d - WORD $0x894c; BYTE $0xfa // movq %r15, %rdx - WORD $0xc389 // movl %eax, %ebx - WORD $0xfb83; BYTE $0x64 // cmpl $100, %ebx - LONG $0xffe8820f; WORD $0xffff // jb LBB36_106, $-24(%rip) +LBB31_100: + WORD $0x8944; BYTE $0xd9 // movl %r11d, %ecx + LONG $0x00004ee9; BYTE $0x00 // jmp LBB31_105, $78(%rip) -LBB36_109: - WORD $0xff48; BYTE $0xca // decq %rdx - LONG $0x65358d48; WORD $0x003b; BYTE $0x00 // leaq $15205(%rip), %rsi /* _Digits(%rip) */ - LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 +LBB31_99: + WORD $0x3145; BYTE $0xc9 // xorl %r9d, %r9d + WORD $0x8945; BYTE $0xeb // movl %r13d, %r11d + LONG $0x64fb8341 // cmpl $100, %r11d + LONG $0xffe8820f; WORD $0xffff // jb LBB31_100, $-24(%rip) -LBB36_110: - WORD $0xd889 // movl %ebx, %eax - LONG $0x1fc06948; WORD $0xeb85; BYTE $0x51 // imulq $1374389535, %rax, %rax - LONG $0x25e8c148 // shrq $37, %rax - WORD $0xf86b; BYTE $0x64 // imull $100, %eax, %edi - WORD $0xd989 // movl %ebx, %ecx - WORD $0xf929 // subl %edi, %ecx - LONG $0x4e0cb70f // movzwl (%rsi,%rcx,2), %ecx - LONG $0xff4a8966 // movw %cx, $-1(%rdx) - LONG $0xfec28348 // addq $-2, %rdx - LONG $0x270ffb81; WORD $0x0000 // cmpl $9999, %ebx - WORD $0xc389 // movl %eax, %ebx - LONG $0xffd2870f; WORD $0xffff // ja LBB36_110, $-46(%rip) +LBB31_103: + WORD $0xff48; BYTE $0xc8 // decq %rax + LONG $0xc2158d48; WORD $0x0037; BYTE $0x00 // leaq $14274(%rip), %rdx /* _Digits(%rip) */ + WORD $0x9090 // .p2align 4, 0x90 -LBB36_111: - WORD $0x894d; BYTE $0xe9 // movq %r13, %r9 - WORD $0xf883; BYTE $0x0a // cmpl $10, %eax - LONG $0x0019820f; WORD $0x0000 // jb LBB36_113, $25(%rip) - WORD $0xc089 // movl %eax, %eax - LONG $0x1d0d8d48; WORD $0x003b; BYTE $0x00 // leaq $15133(%rip), %rcx /* _Digits(%rip) */ +LBB31_104: + WORD $0x8944; BYTE $0xd9 // movl %r11d, %ecx + LONG $0x1fc96948; WORD $0xeb85; BYTE $0x51 // imulq $1374389535, %rcx, %rcx + LONG $0x25e9c148 // shrq $37, %rcx + WORD $0xd96b; BYTE $0x64 // imull $100, %ecx, %ebx + WORD $0x8944; BYTE $0xde // movl %r11d, %esi + WORD $0xde29 // subl %ebx, %esi + LONG $0x7234b70f // movzwl (%rdx,%rsi,2), %esi + LONG $0xff708966 // movw %si, $-1(%rax) + LONG $0xfec08348 // addq $-2, %rax + LONG $0x0ffb8141; WORD $0x0027; BYTE $0x00 // cmpl $9999, %r11d + WORD $0x8941; BYTE $0xcb // movl %ecx, %r11d + LONG $0xffce870f; WORD $0xffff // ja LBB31_104, $-50(%rip) + +LBB31_105: + WORD $0xf983; BYTE $0x0a // cmpl $10, %ecx + LONG $0x0016820f; WORD $0x0000 // jb LBB31_107, $22(%rip) + WORD $0xc889 // movl %ecx, %eax + LONG $0x7c0d8d48; WORD $0x0037; BYTE $0x00 // leaq $14204(%rip), %rcx /* _Digits(%rip) */ LONG $0x4104b70f // movzwl (%rcx,%rax,2), %eax - LONG $0xd04d8b48 // movq $-48(%rbp), %rcx - WORD $0x8966; BYTE $0x01 // movw %ax, (%rcx) - LONG $0x000008e9; BYTE $0x00 // jmp LBB36_114, $8(%rip) - -LBB36_113: - WORD $0x3004 // addb $48, %al - LONG $0xd04d8b48 // movq $-48(%rbp), %rcx - WORD $0x0188 // movb %al, (%rcx) - -LBB36_114: - WORD $0x294d; BYTE $0xf7 // subq %r14, %r15 - WORD $0x294d; BYTE $0xf0 // subq %r14, %r8 - WORD $0xff49; BYTE $0xc0 // incq %r8 - LONG $0x1e048d43 // leal (%r14,%r11), %eax - WORD $0xd8f6 // negb %al - LONG $0x33148d43 // leal (%r11,%r14), %edx - WORD $0xdaf7 // negl %edx - LONG $0x332c8d47 // leal (%r11,%r14), %r13d - WORD $0xff41; BYTE $0xcd // decl %r13d - LONG $0x33348d43 // leal (%r11,%r14), %esi - WORD $0xc683; BYTE $0xfe // addl $-2, %esi - WORD $0xc931 // xorl %ecx, %ecx + LONG $0x00894166 // movw %ax, (%r8) + LONG $0x000006e9; BYTE $0x00 // jmp LBB31_108, $6(%rip) + +LBB31_107: + WORD $0xc180; BYTE $0x30 // addb $48, %cl + WORD $0x8841; BYTE $0x08 // movb %cl, (%r8) + +LBB31_108: + WORD $0x294d; BYTE $0xcc // subq %r9, %r12 + LONG $0x24548d49; BYTE $0x01 // leaq $1(%r12), %rdx + LONG $0x24748d49; BYTE $0x61 // leaq $97(%r12), %rsi + LONG $0x24448d49; BYTE $0x02 // leaq $2(%r12), %rax + LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 - // .p2align 4, 0x90 -LBB36_115: - WORD $0xc389 // movl %eax, %ebx - WORD $0x438d; BYTE $0x03 // leal $3(%rbx), %eax - WORD $0xc6ff // incl %esi - LONG $0x0f7c8041; WORD $0x30ff // cmpb $48, $-1(%r15,%rcx) - LONG $0xff498d48 // leaq $-1(%rcx), %rcx - LONG $0xffe9840f; WORD $0xffff // je LBB36_115, $-23(%rip) - LONG $0x0f048d49 // leaq (%r15,%rcx), %rax - WORD $0xff48; BYTE $0xc0 // incq %rax +LBB31_109: + WORD $0xff48; BYTE $0xce // decq %rsi + WORD $0xff48; BYTE $0xca // decq %rdx + WORD $0xff48; BYTE $0xc8 // decq %rax + LONG $0x207c8043; WORD $0x30ff // cmpb $48, $-1(%r8,%r12) + LONG $0x24648d4d; BYTE $0xff // leaq $-1(%r12), %r12 + LONG $0xffe6840f; WORD $0xffff // je LBB31_109, $-26(%rip) + LONG $0x100c8d4d // leaq (%r8,%rdx), %r9 WORD $0x8545; BYTE $0xd2 // testl %r10d, %r10d - LONG $0x00b28e0f; WORD $0x0000 // jle LBB36_121, $178(%rip) - WORD $0x2945; BYTE $0xf4 // subl %r14d, %r12d - LONG $0x0c3c8d41 // leal (%r12,%rcx), %edi - WORD $0xc7ff // incl %edi - WORD $0x3941; BYTE $0xfa // cmpl %edi, %r10d - LONG $0x002d8d0f; WORD $0x0000 // jge LBB36_122, $45(%rip) - WORD $0x6348; BYTE $0xc2 // movslq %edx, %rax - LONG $0x08348d48 // leaq (%rax,%rcx), %rsi - WORD $0xff48; BYTE $0xc6 // incq %rsi - WORD $0xf685 // testl %esi, %esi - WORD $0x894d; BYTE $0xcd // movq %r9, %r13 - LONG $0x011a8e0f; WORD $0x0000 // jle LBB36_133, $282(%rip) - WORD $0x8941; BYTE $0xf0 // movl %esi, %r8d - LONG $0xff508d49 // leaq $-1(%r8), %rdx - LONG $0x03fa8348 // cmpq $3, %rdx - LONG $0x009a830f; WORD $0x0000 // jae LBB36_127, $154(%rip) - WORD $0xd231 // xorl %edx, %edx - LONG $0x0000c6e9; BYTE $0x00 // jmp LBB36_130, $198(%rip) - -LBB36_122: - WORD $0x8945; BYTE $0xea // movl %r13d, %r10d - WORD $0x2949; BYTE $0xca // subq %rcx, %r10 - WORD $0x8545; BYTE $0xd2 // testl %r10d, %r10d - LONG $0x00648e0f; WORD $0x0000 // jle LBB36_121, $100(%rip) - LONG $0x331c8d43 // leal (%r11,%r14), %ebx - WORD $0xc383; BYTE $0xfe // addl $-2, %ebx - WORD $0x2948; BYTE $0xcb // subq %rcx, %rbx - WORD $0xd231 // xorl %edx, %edx - WORD $0xfb83; BYTE $0x7f // cmpl $127, %ebx - WORD $0x894d; BYTE $0xcd // movq %r9, %r13 - LONG $0x0223820f; WORD $0x0000 // jb LBB36_140, $547(%rip) - WORD $0x0145; BYTE $0xde // addl %r11d, %r14d - LONG $0xfec68341 // addl $-2, %r14d - WORD $0x2949; BYTE $0xce // subq %rcx, %r14 - WORD $0x8941; BYTE $0xdb // movl %ebx, %r11d + LONG $0x00938e0f; WORD $0x0000 // jle LBB31_115, $147(%rip) + WORD $0x8944; BYTE $0xc9 // movl %r9d, %ecx + WORD $0x2944; BYTE $0xc1 // subl %r8d, %ecx + WORD $0xcb89 // movl %ecx, %ebx + WORD $0x2944; BYTE $0xd3 // subl %r10d, %ebx + LONG $0x00278e0f; WORD $0x0000 // jle LBB31_116, $39(%rip) + WORD $0xdb85 // testl %ebx, %ebx + LONG $0x00fa8e0f; WORD $0x0000 // jle LBB31_127, $250(%rip) + WORD $0x8941; BYTE $0xdb // movl %ebx, %r11d + LONG $0xff4b8d49 // leaq $-1(%r11), %rcx + WORD $0x8945; BYTE $0xd9 // movl %r11d, %r9d + LONG $0x03e18341 // andl $3, %r9d + LONG $0x03f98348 // cmpq $3, %rcx + LONG $0x0083830f; WORD $0x0000 // jae LBB31_121, $131(%rip) + WORD $0xc931 // xorl %ecx, %ecx + LONG $0x0000ade9; BYTE $0x00 // jmp LBB31_124, $173(%rip) + +LBB31_116: + WORD $0x8945; BYTE $0xd6 // movl %r10d, %r14d + WORD $0x2941; BYTE $0xce // subl %ecx, %r14d + LONG $0x004f8e0f; WORD $0x0000 // jle LBB31_115, $79(%rip) + WORD $0x0145; BYTE $0xc2 // addl %r8d, %r10d + WORD $0x8945; BYTE $0xcb // movl %r9d, %r11d + WORD $0xf741; BYTE $0xd3 // notl %r11d + WORD $0x0145; BYTE $0xd3 // addl %r10d, %r11d + WORD $0xc031 // xorl %eax, %eax + LONG $0x7efb8341 // cmpl $126, %r11d + LONG $0x01bd860f; WORD $0x0000 // jbe LBB31_134, $445(%rip) WORD $0xff49; BYTE $0xc3 // incq %r11 - WORD $0x894c; BYTE $0xda // movq %r11, %rdx - LONG $0x80e28348 // andq $-128, %rdx - LONG $0xd07d8b48 // movq $-48(%rbp), %rdi - WORD $0x014c; BYTE $0xc7 // addq %r8, %rdi - WORD $0xf089 // movl %esi, %eax - WORD $0xff48; BYTE $0xc0 // incq %rax + WORD $0x894c; BYTE $0xd8 // movq %r11, %rax LONG $0x80e08348 // andq $-128, %rax - WORD $0x0148; BYTE $0xf8 // addq %rdi, %rax - LONG $0x80728d48 // leaq $-128(%rdx), %rsi - WORD $0x8949; BYTE $0xf0 // movq %rsi, %r8 - LONG $0x07e8c149 // shrq $7, %r8 - WORD $0xff49; BYTE $0xc0 // incq %r8 - LONG $0x80fe8148; WORD $0x0001; BYTE $0x00 // cmpq $384, %rsi - LONG $0x00ae830f; WORD $0x0000 // jae LBB36_134, $174(%rip) - WORD $0xf631 // xorl %esi, %esi - LONG $0x000163e9; BYTE $0x00 // jmp LBB36_136, $355(%rip) - -LBB36_121: - WORD $0x894d; BYTE $0xcd // movq %r9, %r13 - LONG $0x0001e0e9; BYTE $0x00 // jmp LBB36_92, $480(%rip) - -LBB36_107: - LONG $0x0004be41; WORD $0x0000 // movl $4, %r14d - LONG $0xfc578d49 // leaq $-4(%r15), %rdx - WORD $0xfb83; BYTE $0x64 // cmpl $100, %ebx - LONG $0xfe65820f; WORD $0xffff // jb LBB36_106, $-411(%rip) - LONG $0xfffe78e9; BYTE $0xff // jmp LBB36_109, $-392(%rip) + LONG $0x000c8d4d // leaq (%r8,%rax), %r9 + LONG $0x80488d48 // leaq $-128(%rax), %rcx + WORD $0x8949; BYTE $0xcf // movq %rcx, %r15 + LONG $0x07efc149 // shrq $7, %r15 + WORD $0xff49; BYTE $0xc7 // incq %r15 + WORD $0x8945; BYTE $0xfa // movl %r15d, %r10d + LONG $0x03e28341 // andl $3, %r10d + LONG $0x80f98148; WORD $0x0001; BYTE $0x00 // cmpq $384, %rcx + LONG $0x0097830f; WORD $0x0000 // jae LBB31_128, $151(%rip) + WORD $0xc931 // xorl %ecx, %ecx + LONG $0x000139e9; BYTE $0x00 // jmp LBB31_130, $313(%rip) -LBB36_127: - WORD $0xe683; BYTE $0xfc // andl $-4, %esi - WORD $0xf748; BYTE $0xde // negq %rsi - WORD $0xd231 // xorl %edx, %edx - QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 +LBB31_115: + WORD $0x894d; BYTE $0xc8 // movq %r9, %r8 + LONG $0x0001a0e9; BYTE $0x00 // jmp LBB31_136, $416(%rip) + +LBB31_101: + LONG $0x0004b941; WORD $0x0000 // movl $4, %r9d + LONG $0xfcc08348 // addq $-4, %rax + LONG $0x64fb8341 // cmpl $100, %r11d + LONG $0xfe96820f; WORD $0xffff // jb LBB31_100, $-362(%rip) + LONG $0xfffea9e9; BYTE $0xff // jmp LBB31_103, $-343(%rip) + +LBB31_121: + LONG $0xfce38341 // andl $-4, %r11d + WORD $0xf749; BYTE $0xdb // negq %r11 + WORD $0xc931 // xorl %ecx, %ecx + QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90 -LBB36_128: - LONG $0x173c8d49 // leaq (%r15,%rdx), %rdi - LONG $0xfd39448b // movl $-3(%rcx,%rdi), %eax - LONG $0xfe394489 // movl %eax, $-2(%rcx,%rdi) - LONG $0xfcc28348 // addq $-4, %rdx - WORD $0x3948; BYTE $0xd6 // cmpq %rdx, %rsi - LONG $0xffe7850f; WORD $0xffff // jne LBB36_128, $-25(%rip) - WORD $0xf748; BYTE $0xda // negq %rdx +LBB31_122: + LONG $0x081c8d49 // leaq (%r8,%rcx), %rbx + LONG $0xfc1a748b // movl $-4(%rdx,%rbx), %esi + LONG $0xfd1a7489 // movl %esi, $-3(%rdx,%rbx) + LONG $0xfcc18348 // addq $-4, %rcx + WORD $0x3949; BYTE $0xcb // cmpq %rcx, %r11 + LONG $0xffe7850f; WORD $0xffff // jne LBB31_122, $-25(%rip) + WORD $0xf748; BYTE $0xd9 // negq %rcx -LBB36_130: - LONG $0x03c0f641 // testb $3, %r8b - LONG $0x0032840f; WORD $0x0000 // je LBB36_133, $50(%rip) - WORD $0xb60f; BYTE $0xc3 // movzbl %bl, %eax - WORD $0xe083; BYTE $0x03 // andl $3, %eax - WORD $0xf748; BYTE $0xd8 // negq %rax - WORD $0x894c; BYTE $0xfe // movq %r15, %rsi - WORD $0x2948; BYTE $0xd6 // subq %rdx, %rsi - WORD $0xd231 // xorl %edx, %edx - QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90 +LBB31_124: + WORD $0x854d; BYTE $0xc9 // testq %r9, %r9 + LONG $0x0025840f; WORD $0x0000 // je LBB31_127, $37(%rip) + WORD $0xf749; BYTE $0xd9 // negq %r9 + WORD $0x894c; BYTE $0xc2 // movq %r8, %rdx + WORD $0x2948; BYTE $0xca // subq %rcx, %rdx + WORD $0xc931 // xorl %ecx, %ecx -LBB36_132: - LONG $0x163c8d48 // leaq (%rsi,%rdx), %rdi - LONG $0x391cb60f // movzbl (%rcx,%rdi), %ebx - LONG $0x01395c88 // movb %bl, $1(%rcx,%rdi) - WORD $0xff48; BYTE $0xca // decq %rdx - WORD $0x3948; BYTE $0xd0 // cmpq %rdx, %rax - LONG $0xffe8850f; WORD $0xffff // jne LBB36_132, $-24(%rip) + // .p2align 4, 0x90 +LBB31_126: + LONG $0x0a348d48 // leaq (%rdx,%rcx), %rsi + LONG $0x1cb60f41; BYTE $0x34 // movzbl (%r12,%rsi), %ebx + LONG $0x345c8841; BYTE $0x01 // movb %bl, $1(%r12,%rsi) + WORD $0xff48; BYTE $0xc9 // decq %rcx + WORD $0x3949; BYTE $0xc9 // cmpq %rcx, %r9 + LONG $0xffe6850f; WORD $0xffff // jne LBB31_126, $-26(%rip) + +LBB31_127: + WORD $0x6349; BYTE $0xca // movslq %r10d, %rcx + LONG $0x0804c641; BYTE $0x2e // movb $46, (%r8,%rcx) + WORD $0x0149; BYTE $0xc0 // addq %rax, %r8 + LONG $0x000118e9; BYTE $0x00 // jmp LBB31_136, $280(%rip) + +LBB31_128: + LONG $0xfce78349 // andq $-4, %r15 + WORD $0xf749; BYTE $0xdf // negq %r15 + WORD $0xc931 // xorl %ecx, %ecx + QUAD $0xfffff3e5056ffdc5 // vmovdqa $-3099(%rip), %ymm0 /* LCPI31_0(%rip) */ + +LBB31_129: + LONG $0x081c8d49 // leaq (%r8,%rcx), %rbx + LONG $0x047ffec5; BYTE $0x1a // vmovdqu %ymm0, (%rdx,%rbx) + LONG $0x447ffec5; WORD $0x201a // vmovdqu %ymm0, $32(%rdx,%rbx) + LONG $0x447ffec5; WORD $0x401a // vmovdqu %ymm0, $64(%rdx,%rbx) + LONG $0x447ffec5; WORD $0x601a // vmovdqu %ymm0, $96(%rdx,%rbx) + QUAD $0x0000801a847ffec5; BYTE $0x00 // vmovdqu %ymm0, $128(%rdx,%rbx) + QUAD $0x0000a01a847ffec5; BYTE $0x00 // vmovdqu %ymm0, $160(%rdx,%rbx) + QUAD $0x0000c01a847ffec5; BYTE $0x00 // vmovdqu %ymm0, $192(%rdx,%rbx) + QUAD $0x0000e01a847ffec5; BYTE $0x00 // vmovdqu %ymm0, $224(%rdx,%rbx) + QUAD $0x0001001a847ffec5; BYTE $0x00 // vmovdqu %ymm0, $256(%rdx,%rbx) + QUAD $0x0001201a847ffec5; BYTE $0x00 // vmovdqu %ymm0, $288(%rdx,%rbx) + QUAD $0x0001401a847ffec5; BYTE $0x00 // vmovdqu %ymm0, $320(%rdx,%rbx) + QUAD $0x0001601a847ffec5; BYTE $0x00 // vmovdqu %ymm0, $352(%rdx,%rbx) + QUAD $0x0001801a847ffec5; BYTE $0x00 // vmovdqu %ymm0, $384(%rdx,%rbx) + QUAD $0x0001a01a847ffec5; BYTE $0x00 // vmovdqu %ymm0, $416(%rdx,%rbx) + QUAD $0x0001c01a847ffec5; BYTE $0x00 // vmovdqu %ymm0, $448(%rdx,%rbx) + QUAD $0x0001e01a847ffec5; BYTE $0x00 // vmovdqu %ymm0, $480(%rdx,%rbx) + LONG $0x00c18148; WORD $0x0002; BYTE $0x00 // addq $512, %rcx + LONG $0x04c78349 // addq $4, %r15 + LONG $0xff68850f; WORD $0xffff // jne LBB31_129, $-152(%rip) -LBB36_133: - WORD $0x8944; BYTE $0xd0 // movl %r10d, %eax - LONG $0xd0558b48 // movq $-48(%rbp), %rdx - LONG $0x2e0204c6 // movb $46, (%rdx,%rax) - LONG $0x0f048d49 // leaq (%r15,%rcx), %rax - LONG $0x02c08348 // addq $2, %rax - LONG $0x000141e9; BYTE $0x00 // jmp LBB36_92, $321(%rip) +LBB31_130: + WORD $0x0149; BYTE $0xd1 // addq %rdx, %r9 + WORD $0x854d; BYTE $0xd2 // testq %r10, %r10 + LONG $0x0035840f; WORD $0x0000 // je LBB31_133, $53(%rip) + WORD $0x0149; BYTE $0xc8 // addq %rcx, %r8 + WORD $0x0149; BYTE $0xf0 // addq %rsi, %r8 + WORD $0xf749; BYTE $0xda // negq %r10 + QUAD $0xfffff330056ffdc5 // vmovdqa $-3280(%rip), %ymm0 /* LCPI31_0(%rip) */ + +LBB31_132: + LONG $0x7f7ec1c4; WORD $0xa040 // vmovdqu %ymm0, $-96(%r8) + LONG $0x7f7ec1c4; WORD $0xc040 // vmovdqu %ymm0, $-64(%r8) + LONG $0x7f7ec1c4; WORD $0xe040 // vmovdqu %ymm0, $-32(%r8) + LONG $0x7f7ec1c4; BYTE $0x00 // vmovdqu %ymm0, (%r8) + LONG $0x80e88349 // subq $-128, %r8 + WORD $0xff49; BYTE $0xc2 // incq %r10 + LONG $0xffdc850f; WORD $0xffff // jne LBB31_132, $-36(%rip) -LBB36_134: - WORD $0x8944; BYTE $0xf3 // movl %r14d, %ebx - WORD $0xff48; BYTE $0xc3 // incq %rbx - LONG $0x80e38348 // andq $-128, %rbx - LONG $0x80c38348 // addq $-128, %rbx - LONG $0x07ebc148 // shrq $7, %rbx - WORD $0xff48; BYTE $0xc3 // incq %rbx - LONG $0xfce38348 // andq $-4, %rbx - WORD $0xf631 // xorl %esi, %esi - QUAD $0xfffff2ed056ffdc5 // vmovdqa $-3347(%rip), %ymm0 /* LCPI36_0(%rip) */ - -LBB36_135: - LONG $0x373c8d49 // leaq (%r15,%rsi), %rdi - LONG $0x447ffec5; WORD $0x0139 // vmovdqu %ymm0, $1(%rcx,%rdi) - LONG $0x447ffec5; WORD $0x2139 // vmovdqu %ymm0, $33(%rcx,%rdi) - LONG $0x447ffec5; WORD $0x4139 // vmovdqu %ymm0, $65(%rcx,%rdi) - LONG $0x447ffec5; WORD $0x6139 // vmovdqu %ymm0, $97(%rcx,%rdi) - QUAD $0x00008139847ffec5; BYTE $0x00 // vmovdqu %ymm0, $129(%rcx,%rdi) - QUAD $0x0000a139847ffec5; BYTE $0x00 // vmovdqu %ymm0, $161(%rcx,%rdi) - QUAD $0x0000c139847ffec5; BYTE $0x00 // vmovdqu %ymm0, $193(%rcx,%rdi) - QUAD $0x0000e139847ffec5; BYTE $0x00 // vmovdqu %ymm0, $225(%rcx,%rdi) - QUAD $0x00010139847ffec5; BYTE $0x00 // vmovdqu %ymm0, $257(%rcx,%rdi) - QUAD $0x00012139847ffec5; BYTE $0x00 // vmovdqu %ymm0, $289(%rcx,%rdi) - QUAD $0x00014139847ffec5; BYTE $0x00 // vmovdqu %ymm0, $321(%rcx,%rdi) - QUAD $0x00016139847ffec5; BYTE $0x00 // vmovdqu %ymm0, $353(%rcx,%rdi) - QUAD $0x00018139847ffec5; BYTE $0x00 // vmovdqu %ymm0, $385(%rcx,%rdi) - QUAD $0x0001a139847ffec5; BYTE $0x00 // vmovdqu %ymm0, $417(%rcx,%rdi) - QUAD $0x0001c139847ffec5; BYTE $0x00 // vmovdqu %ymm0, $449(%rcx,%rdi) - QUAD $0x0001e139847ffec5; BYTE $0x00 // vmovdqu %ymm0, $481(%rcx,%rdi) - LONG $0x00c68148; WORD $0x0002; BYTE $0x00 // addq $512, %rsi - LONG $0xfcc38348 // addq $-4, %rbx - LONG $0xff67850f; WORD $0xffff // jne LBB36_135, $-153(%rip) - -LBB36_136: - WORD $0x0148; BYTE $0xc8 // addq %rcx, %rax - LONG $0x03c0f641 // testb $3, %r8b - LONG $0x005a840f; WORD $0x0000 // je LBB36_139, $90(%rip) - WORD $0xff41; BYTE $0xc6 // incl %r14d - LONG $0x80e68141; WORD $0x0001; BYTE $0x00 // andl $384, %r14d - LONG $0x80c68341 // addl $-128, %r14d - LONG $0x07eec141 // shrl $7, %r14d - WORD $0xfe41; BYTE $0xc6 // incb %r14b - LONG $0xc6b60f45 // movzbl %r14b, %r8d - LONG $0x03e08341 // andl $3, %r8d - LONG $0x07e0c149 // shlq $7, %r8 - WORD $0x014c; BYTE $0xfe // addq %r15, %rsi - LONG $0x61c68348 // addq $97, %rsi - WORD $0xdb31 // xorl %ebx, %ebx - QUAD $0xfffff215056ffdc5 // vmovdqa $-3563(%rip), %ymm0 /* LCPI36_0(%rip) */ - -LBB36_138: - LONG $0x1e3c8d48 // leaq (%rsi,%rbx), %rdi - LONG $0x447ffec5; WORD $0xa039 // vmovdqu %ymm0, $-96(%rcx,%rdi) - LONG $0x447ffec5; WORD $0xc039 // vmovdqu %ymm0, $-64(%rcx,%rdi) - LONG $0x447ffec5; WORD $0xe039 // vmovdqu %ymm0, $-32(%rcx,%rdi) - LONG $0x047ffec5; BYTE $0x39 // vmovdqu %ymm0, (%rcx,%rdi) - LONG $0x80eb8348 // subq $-128, %rbx - WORD $0x3949; BYTE $0xd8 // cmpq %rbx, %r8 - LONG $0xffd8850f; WORD $0xffff // jne LBB36_138, $-40(%rip) +LBB31_133: + WORD $0x894d; BYTE $0xc8 // movq %r9, %r8 + WORD $0x3949; BYTE $0xc3 // cmpq %rax, %r11 + LONG $0x0022840f; WORD $0x0000 // je LBB31_136, $34(%rip) -LBB36_139: - WORD $0x3949; BYTE $0xd3 // cmpq %rdx, %r11 - LONG $0x0015840f; WORD $0x0000 // je LBB36_92, $21(%rip) - LONG $0x90909090 // .p2align 4, 0x90 +LBB31_134: + WORD $0x894d; BYTE $0xc8 // movq %r9, %r8 + QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 -LBB36_140: - WORD $0x00c6; BYTE $0x30 // movb $48, (%rax) - WORD $0xff48; BYTE $0xc0 // incq %rax - WORD $0xc2ff // incl %edx - WORD $0x3944; BYTE $0xd2 // cmpl %r10d, %edx - LONG $0xffef8c0f; WORD $0xffff // jl LBB36_140, $-17(%rip) +LBB31_135: + LONG $0x3000c641 // movb $48, (%r8) + WORD $0xff49; BYTE $0xc0 // incq %r8 + WORD $0xc0ff // incl %eax + WORD $0x3944; BYTE $0xf0 // cmpl %r14d, %eax + LONG $0xffee8c0f; WORD $0xffff // jl LBB31_135, $-18(%rip) -LBB36_92: - WORD $0x2944; BYTE $0xe8 // subl %r13d, %eax +LBB31_136: + WORD $0x2941; BYTE $0xf8 // subl %edi, %r8d -LBB36_93: - LONG $0x08c48348 // addq $8, %rsp +LBB31_137: + WORD $0x8944; BYTE $0xc0 // movl %r8d, %eax BYTE $0x5b // popq %rbx WORD $0x5c41 // popq %r12 WORD $0x5d41 // popq %r13 @@ -9672,45 +9992,44 @@ LBB36_93: WORD $0xf8c5; BYTE $0x77 // vzeroupper BYTE $0xc3 // retq -LBB36_141: - WORD $0xc031 // xorl %eax, %eax - LONG $0xffffe7e9; BYTE $0xff // jmp LBB36_93, $-25(%rip) +LBB31_138: + WORD $0x3145; BYTE $0xc0 // xorl %r8d, %r8d + LONG $0xffffe7e9; BYTE $0xff // jmp LBB31_137, $-25(%rip) -LBB36_142: - LONG $0xd07d8948 // movq %rdi, $-48(%rbp) - LONG $0xff6bb841; WORD $0xffff // movl $-149, %r8d - WORD $0x8941; BYTE $0xc7 // movl %eax, %r15d - LONG $0xfff257e9; BYTE $0xff // jmp LBB36_8, $-3497(%rip) - BYTE $0x90 // .p2align 4, 0x90 +LBB31_139: + LONG $0xff6bbf41; WORD $0xffff // movl $-149, %r15d + WORD $0xc689 // movl %eax, %esi + LONG $0xfff352e9; BYTE $0xff // jmp LBB31_5, $-3246(%rip) + LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 _format_significand: BYTE $0x55 // pushq %rbp WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp WORD $0x5641 // pushq %r14 BYTE $0x53 // pushq %rbx - WORD $0x8941; BYTE $0xd0 // movl %edx, %r8d + WORD $0x634c; BYTE $0xc2 // movslq %edx, %r8 WORD $0x0149; BYTE $0xf0 // addq %rsi, %r8 WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax LONG $0x20e8c148 // shrq $32, %rax - LONG $0x001c850f; WORD $0x0000 // jne LBB37_2, $28(%rip) + LONG $0x001c850f; WORD $0x0000 // jne LBB32_2, $28(%rip) WORD $0x3145; BYTE $0xc9 // xorl %r9d, %r9d WORD $0x894d; BYTE $0xc6 // movq %r8, %r14 WORD $0x8948; BYTE $0xfa // movq %rdi, %rdx LONG $0x2710fa81; WORD $0x0000 // cmpl $10000, %edx - LONG $0x00e3830f; WORD $0x0000 // jae LBB37_8, $227(%rip) + LONG $0x00e3830f; WORD $0x0000 // jae LBB32_8, $227(%rip) -LBB37_7: +LBB32_7: WORD $0xd789 // movl %edx, %edi - LONG $0x000132e9; BYTE $0x00 // jmp LBB37_10, $306(%rip) + LONG $0x000132e9; BYTE $0x00 // jmp LBB32_10, $306(%rip) -LBB37_2: +LBB32_2: QUAD $0x77118461cefdb948; WORD $0xabcc // movabsq $-6067343680855748867, %rcx WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax WORD $0xf748; BYTE $0xe1 // mulq %rcx LONG $0x1aeac148 // shrq $26, %rdx LONG $0x1f00ca69; WORD $0xfa0a // imull $-100000000, %edx, %ecx WORD $0xf901 // addl %edi, %ecx - LONG $0x00a4840f; WORD $0x0000 // je LBB37_3, $164(%rip) + LONG $0x00a4840f; WORD $0x0000 // je LBB32_3, $164(%rip) WORD $0xc889 // movl %ecx, %eax LONG $0x1759b941; WORD $0xd1b7 // movl $3518437209, %r9d LONG $0xc1af0f49 // imulq %r9, %rax @@ -9736,7 +10055,7 @@ LBB37_2: WORD $0xcf6b; BYTE $0x64 // imull $100, %edi, %ecx WORD $0xc829 // subl %ecx, %eax LONG $0xd8b70f44 // movzwl %ax, %r11d - LONG $0x330d8d48; WORD $0x0037; BYTE $0x00 // leaq $14131(%rip), %rcx /* _Digits(%rip) */ + LONG $0x030d8d48; WORD $0x0034; BYTE $0x00 // leaq $13315(%rip), %rcx /* _Digits(%rip) */ LONG $0x04b70f42; BYTE $0x51 // movzwl (%rcx,%r10,2), %eax LONG $0x40894166; BYTE $0xfe // movw %ax, $-2(%r8) LONG $0x04b70f42; BYTE $0x49 // movzwl (%rcx,%r9,2), %eax @@ -9748,21 +10067,21 @@ LBB37_2: WORD $0x3145; BYTE $0xc9 // xorl %r9d, %r9d LONG $0xf8708d4d // leaq $-8(%r8), %r14 LONG $0x2710fa81; WORD $0x0000 // cmpl $10000, %edx - LONG $0xff38820f; WORD $0xffff // jb LBB37_7, $-200(%rip) - LONG $0x000016e9; BYTE $0x00 // jmp LBB37_8, $22(%rip) + LONG $0xff38820f; WORD $0xffff // jb LBB32_7, $-200(%rip) + LONG $0x000016e9; BYTE $0x00 // jmp LBB32_8, $22(%rip) -LBB37_3: +LBB32_3: LONG $0x0008b941; WORD $0x0000 // movl $8, %r9d LONG $0xf8708d4d // leaq $-8(%r8), %r14 LONG $0x2710fa81; WORD $0x0000 // cmpl $10000, %edx - LONG $0xff1d820f; WORD $0xffff // jb LBB37_7, $-227(%rip) + LONG $0xff1d820f; WORD $0xffff // jb LBB32_7, $-227(%rip) -LBB37_8: +LBB32_8: LONG $0x1759ba41; WORD $0xd1b7 // movl $3518437209, %r10d - LONG $0xd11d8d4c; WORD $0x0036; BYTE $0x00 // leaq $14033(%rip), %r11 /* _Digits(%rip) */ + LONG $0xa11d8d4c; WORD $0x0033; BYTE $0x00 // leaq $13217(%rip), %r11 /* _Digits(%rip) */ BYTE $0x90 // .p2align 4, 0x90 -LBB37_9: +LBB32_9: WORD $0xd789 // movl %edx, %edi LONG $0xfaaf0f49 // imulq %r10, %rdi LONG $0x2defc148 // shrq $45, %rdi @@ -9779,22 +10098,22 @@ LBB37_9: LONG $0xfcc68349 // addq $-4, %r14 LONG $0xe0fffa81; WORD $0x05f5 // cmpl $99999999, %edx WORD $0xfa89 // movl %edi, %edx - LONG $0xffb8870f; WORD $0xffff // ja LBB37_9, $-72(%rip) + LONG $0xffb8870f; WORD $0xffff // ja LBB32_9, $-72(%rip) -LBB37_10: +LBB32_10: WORD $0xff83; BYTE $0x64 // cmpl $100, %edi - LONG $0x0020830f; WORD $0x0000 // jae LBB37_11, $32(%rip) + LONG $0x0020830f; WORD $0x0000 // jae LBB32_11, $32(%rip) WORD $0xff83; BYTE $0x0a // cmpl $10, %edi - LONG $0x004d820f; WORD $0x0000 // jb LBB37_14, $77(%rip) + LONG $0x004d820f; WORD $0x0000 // jb LBB32_14, $77(%rip) -LBB37_13: +LBB32_13: WORD $0xf889 // movl %edi, %eax - LONG $0x6d0d8d48; WORD $0x0036; BYTE $0x00 // leaq $13933(%rip), %rcx /* _Digits(%rip) */ + LONG $0x3d0d8d48; WORD $0x0033; BYTE $0x00 // leaq $13117(%rip), %rcx /* _Digits(%rip) */ LONG $0x4104b70f // movzwl (%rcx,%rax,2), %eax LONG $0x46894166; BYTE $0xfe // movw %ax, $-2(%r14) - LONG $0x00003de9; BYTE $0x00 // jmp LBB37_15, $61(%rip) + LONG $0x00003de9; BYTE $0x00 // jmp LBB32_15, $61(%rip) -LBB37_11: +LBB32_11: WORD $0xb70f; BYTE $0xc7 // movzwl %di, %eax WORD $0xe8c1; BYTE $0x02 // shrl $2, %eax LONG $0x147bc069; WORD $0x0000 // imull $5243, %eax, %eax @@ -9802,19 +10121,19 @@ LBB37_11: WORD $0xc86b; BYTE $0x64 // imull $100, %eax, %ecx WORD $0xcf29 // subl %ecx, %edi WORD $0xb70f; BYTE $0xcf // movzwl %di, %ecx - LONG $0x41158d48; WORD $0x0036; BYTE $0x00 // leaq $13889(%rip), %rdx /* _Digits(%rip) */ + LONG $0x11158d48; WORD $0x0033; BYTE $0x00 // leaq $13073(%rip), %rdx /* _Digits(%rip) */ LONG $0x4a0cb70f // movzwl (%rdx,%rcx,2), %ecx LONG $0x4e894166; BYTE $0xfe // movw %cx, $-2(%r14) LONG $0xfec68349 // addq $-2, %r14 WORD $0xc789 // movl %eax, %edi WORD $0xff83; BYTE $0x0a // cmpl $10, %edi - LONG $0xffb3830f; WORD $0xffff // jae LBB37_13, $-77(%rip) + LONG $0xffb3830f; WORD $0xffff // jae LBB32_13, $-77(%rip) -LBB37_14: +LBB32_14: LONG $0x30c78040 // addb $48, %dil WORD $0x8840; BYTE $0x3e // movb %dil, (%rsi) -LBB37_15: +LBB32_15: WORD $0x294d; BYTE $0xc8 // subq %r9, %r8 WORD $0x894c; BYTE $0xc0 // movq %r8, %rax BYTE $0x5b // popq %rbx @@ -9826,170 +10145,166 @@ LBB37_15: _left_shift: BYTE $0x55 // pushq %rbp WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp - WORD $0x5741 // pushq %r15 WORD $0x5641 // pushq %r14 BYTE $0x53 // pushq %rbx WORD $0xf189 // movl %esi, %ecx - LONG $0x68c16b48 // imulq $104, %rcx, %rax - LONG $0xea158d48; WORD $0x008f; BYTE $0x00 // leaq $36842(%rip), %rdx /* _LSHIFT_TAB(%rip) */ - LONG $0x10048b44 // movl (%rax,%rdx), %r8d - WORD $0x8b4c; BYTE $0x0f // movq (%rdi), %r9 - WORD $0x0148; BYTE $0xc2 // addq %rax, %rdx - LONG $0x04c28348 // addq $4, %rdx - LONG $0x10476348 // movslq $16(%rdi), %rax + LONG $0x68d16b48 // imulq $104, %rcx, %rdx + LONG $0xbc358d48; WORD $0x008c; BYTE $0x00 // leaq $36028(%rip), %rsi /* _LSHIFT_TAB(%rip) */ + LONG $0x32048b44 // movl (%rdx,%rsi), %r8d + WORD $0x8b4c; BYTE $0x17 // movq (%rdi), %r10 + LONG $0x104f634c // movslq $16(%rdi), %r9 + LONG $0x0432448a // movb $4(%rdx,%rsi), %al + WORD $0x854d; BYTE $0xc9 // testq %r9, %r9 + LONG $0x0036840f; WORD $0x0000 // je LBB33_6, $54(%rip) + LONG $0x32548d48; BYTE $0x05 // leaq $5(%rdx,%rsi), %rdx WORD $0xf631 // xorl %esi, %esi - WORD $0x8548; BYTE $0xc0 // testq %rax, %rax - LONG $0x0031840f; WORD $0x0000 // je LBB38_6, $49(%rip) QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 -LBB38_1: - LONG $0x321cb60f // movzbl (%rdx,%rsi), %ebx - WORD $0xdb84 // testb %bl, %bl - LONG $0x0025840f; WORD $0x0000 // je LBB38_8, $37(%rip) - LONG $0x311c3841 // cmpb %bl, (%r9,%rsi) - LONG $0x0189850f; WORD $0x0000 // jne LBB38_3, $393(%rip) +LBB33_3: + WORD $0xc084 // testb %al, %al + LONG $0x0025840f; WORD $0x0000 // je LBB33_8, $37(%rip) + LONG $0x32043841 // cmpb %al, (%r10,%rsi) + LONG $0x0189850f; WORD $0x0000 // jne LBB33_5, $393(%rip) + LONG $0x3204b60f // movzbl (%rdx,%rsi), %eax WORD $0xff48; BYTE $0xc6 // incq %rsi - WORD $0x3948; BYTE $0xf0 // cmpq %rsi, %rax - LONG $0xffde850f; WORD $0xffff // jne LBB38_1, $-34(%rip) - WORD $0xc689 // movl %eax, %esi + WORD $0x3949; BYTE $0xf1 // cmpq %rsi, %r9 + LONG $0xffde850f; WORD $0xffff // jne LBB33_3, $-34(%rip) -LBB38_6: - LONG $0x00323c80 // cmpb $0, (%rdx,%rsi) - LONG $0x0003840f; WORD $0x0000 // je LBB38_8, $3(%rip) +LBB33_6: + WORD $0xc084 // testb %al, %al + LONG $0x0003840f; WORD $0x0000 // je LBB33_8, $3(%rip) -LBB38_7: +LBB33_7: WORD $0xff41; BYTE $0xc8 // decl %r8d -LBB38_8: - WORD $0xc085 // testl %eax, %eax - LONG $0x00968e0f; WORD $0x0000 // jle LBB38_22, $150(%rip) - LONG $0x001c8d45 // leal (%r8,%rax), %r11d - WORD $0xc389 // movl %eax, %ebx - WORD $0x634d; BYTE $0xf3 // movslq %r11d, %r14 - WORD $0xff49; BYTE $0xce // decq %r14 - WORD $0xff48; BYTE $0xc3 // incq %rbx - WORD $0xd231 // xorl %edx, %edx - QUAD $0xcccccccccccdba49; WORD $0xcccc // movabsq $-3689348814741910323, %r10 - LONG $0x000023e9; BYTE $0x00 // jmp LBB38_10, $35(%rip) - LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 - -LBB38_11: - WORD $0x3004 // addb $48, %al - LONG $0x31048843 // movb %al, (%r9,%r14) - WORD $0x8b4c; BYTE $0x0f // movq (%rdi), %r9 +LBB33_8: + WORD $0x8545; BYTE $0xc9 // testl %r9d, %r9d + LONG $0x008c8e0f; WORD $0x0000 // jle LBB33_23, $140(%rip) + LONG $0x08048d43 // leal (%r8,%r9), %eax + WORD $0x634c; BYTE $0xf0 // movslq %eax, %r14 + WORD $0xff49; BYTE $0xce // decq %r14 + WORD $0xd231 // xorl %edx, %edx + QUAD $0xcccccccccccdbb49; WORD $0xcccc // movabsq $-3689348814741910323, %r11 + LONG $0x90909090 // .p2align 4, 0x90 -LBB38_18: - WORD $0xff41; BYTE $0xcb // decl %r11d - WORD $0xff49; BYTE $0xce // decq %r14 - WORD $0xff48; BYTE $0xcb // decq %rbx - LONG $0x01fb8348 // cmpq $1, %rbx - LONG $0x0049860f; WORD $0x0000 // jbe LBB38_12, $73(%rip) +LBB33_10: + LONG $0x74be0f4b; WORD $0xff0a // movsbq $-1(%r10,%r9), %rsi + LONG $0xd0c68348 // addq $-48, %rsi + WORD $0xd348; BYTE $0xe6 // shlq %cl, %rsi + WORD $0x0148; BYTE $0xd6 // addq %rdx, %rsi + WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax + WORD $0xf749; BYTE $0xe3 // mulq %r11 + LONG $0x03eac148 // shrq $3, %rdx + LONG $0x12048d48 // leaq (%rdx,%rdx), %rax + LONG $0x801c8d48 // leaq (%rax,%rax,4), %rbx + WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax + WORD $0x2948; BYTE $0xd8 // subq %rbx, %rax + LONG $0x0877394c // cmpq %r14, $8(%rdi) + LONG $0x000e860f; WORD $0x0000 // jbe LBB33_16, $14(%rip) + WORD $0x3004 // addb $48, %al + LONG $0x32048843 // movb %al, (%r10,%r14) + LONG $0x000013e9; BYTE $0x00 // jmp LBB33_18, $19(%rip) + WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 -LBB38_10: - WORD $0x438d; BYTE $0xfe // leal $-2(%rbx), %eax - LONG $0x34be0f49; BYTE $0x01 // movsbq (%r9,%rax), %rsi - LONG $0xd0c68348 // addq $-48, %rsi - WORD $0xd348; BYTE $0xe6 // shlq %cl, %rsi - WORD $0x0148; BYTE $0xd6 // addq %rdx, %rsi - WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax - WORD $0xf749; BYTE $0xe2 // mulq %r10 - LONG $0x03eac148 // shrq $3, %rdx - LONG $0x12048d48 // leaq (%rdx,%rdx), %rax - LONG $0x803c8d4c // leaq (%rax,%rax,4), %r15 - WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax - WORD $0x294c; BYTE $0xf8 // subq %r15, %rax - LONG $0x0877394c // cmpq %r14, $8(%rdi) - LONG $0xffb0870f; WORD $0xffff // ja LBB38_11, $-80(%rip) +LBB33_16: WORD $0x8548; BYTE $0xc0 // testq %rax, %rax - LONG $0xffb0840f; WORD $0xffff // je LBB38_18, $-80(%rip) + LONG $0x0007840f; WORD $0x0000 // je LBB33_18, $7(%rip) LONG $0x011c47c7; WORD $0x0000; BYTE $0x00 // movl $1, $28(%rdi) - LONG $0xffffa4e9; BYTE $0xff // jmp LBB38_18, $-92(%rip) -LBB38_12: +LBB33_18: + LONG $0x02f98349 // cmpq $2, %r9 + LONG $0x000e8c0f; WORD $0x0000 // jl LBB33_12, $14(%rip) + WORD $0xff49; BYTE $0xc9 // decq %r9 + WORD $0x8b4c; BYTE $0x17 // movq (%rdi), %r10 + WORD $0xff49; BYTE $0xce // decq %r14 + LONG $0xffff98e9; BYTE $0xff // jmp LBB33_10, $-104(%rip) + +LBB33_12: LONG $0x0afe8348 // cmpq $10, %rsi - LONG $0x0070830f; WORD $0x0000 // jae LBB38_13, $112(%rip) + LONG $0x0067830f; WORD $0x0000 // jae LBB33_13, $103(%rip) -LBB38_22: - LONG $0x10476348 // movslq $16(%rdi), %rax - WORD $0x6349; BYTE $0xc8 // movslq %r8d, %rcx - WORD $0x0148; BYTE $0xc1 // addq %rax, %rcx - WORD $0x4f89; BYTE $0x10 // movl %ecx, $16(%rdi) - LONG $0x08478b48 // movq $8(%rdi), %rax - WORD $0x3948; BYTE $0xc8 // cmpq %rcx, %rax - LONG $0x0005870f; WORD $0x0000 // ja LBB38_24, $5(%rip) +LBB33_23: + LONG $0x104f6348 // movslq $16(%rdi), %rcx + WORD $0x6349; BYTE $0xc0 // movslq %r8d, %rax + WORD $0x0148; BYTE $0xc8 // addq %rcx, %rax WORD $0x4789; BYTE $0x10 // movl %eax, $16(%rdi) - WORD $0xc189 // movl %eax, %ecx - -LBB38_24: - LONG $0x14470144 // addl %r8d, $20(%rdi) - WORD $0xc985 // testl %ecx, %ecx - LONG $0x00318e0f; WORD $0x0000 // jle LBB38_28, $49(%rip) - WORD $0x8b48; BYTE $0x07 // movq (%rdi), %rax - WORD $0xc989 // movl %ecx, %ecx - BYTE $0x90 // .p2align 4, 0x90 - -LBB38_26: - LONG $0xff518d48 // leaq $-1(%rcx), %rdx - WORD $0xd689 // movl %edx, %esi - LONG $0x30303c80 // cmpb $48, (%rax,%rsi) - LONG $0x0028850f; WORD $0x0000 // jne LBB38_30, $40(%rip) - WORD $0xc9ff // decl %ecx + LONG $0x084f8b48 // movq $8(%rdi), %rcx + WORD $0x3948; BYTE $0xc1 // cmpq %rax, %rcx + LONG $0x0005870f; WORD $0x0000 // ja LBB33_25, $5(%rip) WORD $0x4f89; BYTE $0x10 // movl %ecx, $16(%rdi) - LONG $0x01728d48 // leaq $1(%rdx), %rsi - WORD $0x8948; BYTE $0xd1 // movq %rdx, %rcx - LONG $0x01fe8348 // cmpq $1, %rsi - LONG $0xffda870f; WORD $0xffff // ja LBB38_26, $-38(%rip) - LONG $0x000006e9; BYTE $0x00 // jmp LBB38_29, $6(%rip) + WORD $0xc889 // movl %ecx, %eax -LBB38_28: - LONG $0x0007850f; WORD $0x0000 // jne LBB38_30, $7(%rip) +LBB33_25: + LONG $0x14470144 // addl %r8d, $20(%rdi) + WORD $0xc085 // testl %eax, %eax + LONG $0x002f8e0f; WORD $0x0000 // jle LBB33_29, $47(%rip) + WORD $0x8b48; BYTE $0x0f // movq (%rdi), %rcx + WORD $0xc289 // movl %eax, %edx + WORD $0xff48; BYTE $0xc2 // incq %rdx + QUAD $0x9090909090909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 -LBB38_29: - LONG $0x001447c7; WORD $0x0000; BYTE $0x00 // movl $0, $20(%rdi) +LBB33_27: + WORD $0xc8ff // decl %eax + LONG $0x30013c80 // cmpb $48, (%rcx,%rax) + LONG $0x0018850f; WORD $0x0000 // jne LBB33_31, $24(%rip) + WORD $0x4789; BYTE $0x10 // movl %eax, $16(%rdi) + WORD $0xff48; BYTE $0xca // decq %rdx + LONG $0x01fa8348 // cmpq $1, %rdx + LONG $0xffe48f0f; WORD $0xffff // jg LBB33_27, $-28(%rip) -LBB38_30: +LBB33_29: + WORD $0xc085 // testl %eax, %eax + LONG $0x006b840f; WORD $0x0000 // je LBB33_30, $107(%rip) + +LBB33_31: BYTE $0x5b // popq %rbx WORD $0x5e41 // popq %r14 - WORD $0x5f41 // popq %r15 BYTE $0x5d // popq %rbp BYTE $0xc3 // retq -LBB38_13: - WORD $0x6349; BYTE $0xf3 // movslq %r11d, %rsi - WORD $0xff48; BYTE $0xce // decq %rsi - LONG $0x00001be9; BYTE $0x00 // jmp LBB38_14, $27(%rip) - LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 +LBB33_13: + WORD $0x6349; BYTE $0xf6 // movslq %r14d, %rsi + WORD $0xff48; BYTE $0xce // decq %rsi + LONG $0x000021e9; BYTE $0x00 // jmp LBB33_14, $33(%rip) + QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90 -LBB38_15: +LBB33_15: WORD $0x3004 // addb $48, %al WORD $0x8b48; BYTE $0x1f // movq (%rdi), %rbx WORD $0x0488; BYTE $0x33 // movb %al, (%rbx,%rsi) -LBB38_21: +LBB33_22: WORD $0xff48; BYTE $0xce // decq %rsi LONG $0x09f98348 // cmpq $9, %rcx - LONG $0xff6a860f; WORD $0xffff // jbe LBB38_22, $-150(%rip) + LONG $0xff6d860f; WORD $0xffff // jbe LBB33_23, $-147(%rip) -LBB38_14: +LBB33_14: WORD $0x8948; BYTE $0xd1 // movq %rdx, %rcx WORD $0x8948; BYTE $0xd0 // movq %rdx, %rax - WORD $0xf749; BYTE $0xe2 // mulq %r10 + WORD $0xf749; BYTE $0xe3 // mulq %r11 LONG $0x03eac148 // shrq $3, %rdx LONG $0x12048d48 // leaq (%rdx,%rdx), %rax LONG $0x801c8d48 // leaq (%rax,%rax,4), %rbx WORD $0x8948; BYTE $0xc8 // movq %rcx, %rax WORD $0x2948; BYTE $0xd8 // subq %rbx, %rax LONG $0x08773948 // cmpq %rsi, $8(%rdi) - LONG $0xffc6870f; WORD $0xffff // ja LBB38_15, $-58(%rip) + LONG $0xffc6870f; WORD $0xffff // ja LBB33_15, $-58(%rip) WORD $0x8548; BYTE $0xc0 // testq %rax, %rax - LONG $0xffc5840f; WORD $0xffff // je LBB38_21, $-59(%rip) + LONG $0xffc5840f; WORD $0xffff // je LBB33_22, $-59(%rip) LONG $0x011c47c7; WORD $0x0000; BYTE $0x00 // movl $1, $28(%rdi) - LONG $0xffffb9e9; BYTE $0xff // jmp LBB38_21, $-71(%rip) + LONG $0xffffb9e9; BYTE $0xff // jmp LBB33_22, $-71(%rip) -LBB38_3: - LONG $0xfe898c0f; WORD $0xffff // jl LBB38_7, $-375(%rip) - LONG $0xfffe87e9; BYTE $0xff // jmp LBB38_8, $-377(%rip) - LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 +LBB33_30: + LONG $0x001447c7; WORD $0x0000; BYTE $0x00 // movl $0, $20(%rdi) + BYTE $0x5b // popq %rbx + WORD $0x5e41 // popq %r14 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB33_5: + LONG $0xfe898c0f; WORD $0xffff // jl LBB33_7, $-375(%rip) + LONG $0xfffe87e9; BYTE $0xff // jmp LBB33_8, $-377(%rip) + QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90 _right_shift: BYTE $0x55 // pushq %rbp @@ -10000,26 +10315,25 @@ _right_shift: WORD $0xd231 // xorl %edx, %edx WORD $0x8545; BYTE $0xc0 // testl %r8d, %r8d LONG $0x0000bb41; WORD $0x0000 // movl $0, %r11d - LONG $0xd84f0f45 // cmovgl %r8d, %r11d + LONG $0xd8490f45 // cmovnsl %r8d, %r11d WORD $0xc031 // xorl %eax, %eax LONG $0x90909090 // .p2align 4, 0x90 -LBB39_1: +LBB34_1: WORD $0x3949; BYTE $0xd3 // cmpq %rdx, %r11 - LONG $0x0132840f; WORD $0x0000 // je LBB39_2, $306(%rip) + LONG $0x0132840f; WORD $0x0000 // je LBB34_2, $306(%rip) LONG $0x80048d48 // leaq (%rax,%rax,4), %rax WORD $0x8b48; BYTE $0x37 // movq (%rdi), %rsi LONG $0x34be0f48; BYTE $0x16 // movsbq (%rsi,%rdx), %rsi - LONG $0x46048d48 // leaq (%rsi,%rax,2), %rax - LONG $0xd0c08348 // addq $-48, %rax + LONG $0x46448d48; BYTE $0xd0 // leaq $-48(%rsi,%rax,2), %rax WORD $0xff48; BYTE $0xc2 // incq %rdx WORD $0x8948; BYTE $0xc6 // movq %rax, %rsi WORD $0xd348; BYTE $0xee // shrq %cl, %rsi WORD $0x8548; BYTE $0xf6 // testq %rsi, %rsi - LONG $0xffd1840f; WORD $0xffff // je LBB39_1, $-47(%rip) + LONG $0xffd4840f; WORD $0xffff // je LBB34_1, $-44(%rip) WORD $0x8941; BYTE $0xd3 // movl %edx, %r11d -LBB39_7: +LBB34_7: WORD $0x578b; BYTE $0x14 // movl $20(%rdi), %edx WORD $0x2944; BYTE $0xda // subl %r11d, %edx WORD $0xc2ff // incl %edx @@ -10029,122 +10343,119 @@ LBB39_7: WORD $0xf749; BYTE $0xd1 // notq %r9 WORD $0x3145; BYTE $0xd2 // xorl %r10d, %r10d WORD $0x3945; BYTE $0xc3 // cmpl %r8d, %r11d - LONG $0x00718d0f; WORD $0x0000 // jge LBB39_10, $113(%rip) + LONG $0x00648d0f; WORD $0x0000 // jge LBB34_10, $100(%rip) WORD $0x634d; BYTE $0xc3 // movslq %r11d, %r8 WORD $0x8b48; BYTE $0x37 // movq (%rdi), %rsi WORD $0x3145; BYTE $0xd2 // xorl %r10d, %r10d - BYTE $0x90 // .p2align 4, 0x90 + LONG $0x90909090 // .p2align 4, 0x90 -LBB39_9: - WORD $0x8948; BYTE $0xc2 // movq %rax, %rdx - WORD $0xd348; BYTE $0xea // shrq %cl, %rdx - WORD $0x214c; BYTE $0xc8 // andq %r9, %rax - WORD $0xc280; BYTE $0x30 // addb $48, %dl - LONG $0x16148842 // movb %dl, (%rsi,%r10) - WORD $0x8b48; BYTE $0x37 // movq (%rdi), %rsi - LONG $0x06148d4a // leaq (%rsi,%r8), %rdx - LONG $0x1cbe0f4d; BYTE $0x12 // movsbq (%r10,%rdx), %r11 - LONG $0x105c8d4b; BYTE $0x01 // leaq $1(%r8,%r10), %rbx - WORD $0xff49; BYTE $0xc2 // incq %r10 - LONG $0x80048d48 // leaq (%rax,%rax,4), %rax - LONG $0x43048d49 // leaq (%r11,%rax,2), %rax - LONG $0xd0c08348 // addq $-48, %rax - LONG $0x10576348 // movslq $16(%rdi), %rdx - WORD $0x3948; BYTE $0xd3 // cmpq %rdx, %rbx - LONG $0xffc38c0f; WORD $0xffff // jl LBB39_9, $-61(%rip) - LONG $0x000025e9; BYTE $0x00 // jmp LBB39_10, $37(%rip) - QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 +LBB34_9: + WORD $0x8948; BYTE $0xc2 // movq %rax, %rdx + WORD $0xd348; BYTE $0xea // shrq %cl, %rdx + WORD $0x214c; BYTE $0xc8 // andq %r9, %rax + WORD $0xc280; BYTE $0x30 // addb $48, %dl + LONG $0x16148842 // movb %dl, (%rsi,%r10) + WORD $0x8b48; BYTE $0x37 // movq (%rdi), %rsi + LONG $0x06148d4a // leaq (%rsi,%r8), %rdx + LONG $0x1cbe0f4d; BYTE $0x12 // movsbq (%r10,%rdx), %r11 + LONG $0x105c8d4b; BYTE $0x01 // leaq $1(%r8,%r10), %rbx + LONG $0x01528d4d // leaq $1(%r10), %r10 + LONG $0x80048d48 // leaq (%rax,%rax,4), %rax + LONG $0x43448d49; BYTE $0xd0 // leaq $-48(%r11,%rax,2), %rax + LONG $0x10576348 // movslq $16(%rdi), %rdx + WORD $0x3948; BYTE $0xd3 // cmpq %rdx, %rbx + LONG $0xffc58c0f; WORD $0xffff // jl LBB34_9, $-59(%rip) + LONG $0x000017e9; BYTE $0x00 // jmp LBB34_10, $23(%rip) -LBB39_12: + // .p2align 4, 0x90 +LBB34_12: LONG $0x30c68040 // addb $48, %sil WORD $0x8b48; BYTE $0x1f // movq (%rdi), %rbx LONG $0x13348840 // movb %sil, (%rbx,%rdx) WORD $0xc2ff // incl %edx WORD $0x8941; BYTE $0xd2 // movl %edx, %r10d -LBB39_15: +LBB34_15: WORD $0x0148; BYTE $0xc0 // addq %rax, %rax LONG $0x80048d48 // leaq (%rax,%rax,4), %rax -LBB39_10: +LBB34_10: WORD $0x8548; BYTE $0xc0 // testq %rax, %rax - LONG $0x002b840f; WORD $0x0000 // je LBB39_16, $43(%rip) + LONG $0x002b840f; WORD $0x0000 // je LBB34_16, $43(%rip) WORD $0x8948; BYTE $0xc6 // movq %rax, %rsi WORD $0xd348; BYTE $0xee // shrq %cl, %rsi WORD $0x214c; BYTE $0xc8 // andq %r9, %rax WORD $0x6349; BYTE $0xd2 // movslq %r10d, %rdx LONG $0x08573948 // cmpq %rdx, $8(%rdi) - LONG $0xffca870f; WORD $0xffff // ja LBB39_12, $-54(%rip) + LONG $0xffca870f; WORD $0xffff // ja LBB34_12, $-54(%rip) WORD $0x8548; BYTE $0xf6 // testq %rsi, %rsi - LONG $0xffd1840f; WORD $0xffff // je LBB39_15, $-47(%rip) + LONG $0xffd1840f; WORD $0xffff // je LBB34_15, $-47(%rip) LONG $0x011c47c7; WORD $0x0000; BYTE $0x00 // movl $1, $28(%rdi) - LONG $0xffffc5e9; BYTE $0xff // jmp LBB39_15, $-59(%rip) + LONG $0xffffc5e9; BYTE $0xff // jmp LBB34_15, $-59(%rip) + +LBB34_16: + LONG $0x10578944 // movl %r10d, $16(%rdi) + WORD $0x8545; BYTE $0xd2 // testl %r10d, %r10d + LONG $0x00378e0f; WORD $0x0000 // jle LBB34_20, $55(%rip) + WORD $0x8b48; BYTE $0x07 // movq (%rdi), %rax + WORD $0x8944; BYTE $0xd1 // movl %r10d, %ecx + WORD $0xff48; BYTE $0xc1 // incq %rcx + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 -LBB39_16: +LBB34_18: + WORD $0xff41; BYTE $0xca // decl %r10d + LONG $0x103c8042; BYTE $0x30 // cmpb $48, (%rax,%r10) + LONG $0x001a850f; WORD $0x0000 // jne LBB34_22, $26(%rip) LONG $0x10578944 // movl %r10d, $16(%rdi) + WORD $0xff48; BYTE $0xc9 // decq %rcx + LONG $0x01f98348 // cmpq $1, %rcx + LONG $0xffe18f0f; WORD $0xffff // jg LBB34_18, $-31(%rip) + +LBB34_20: WORD $0x8545; BYTE $0xd2 // testl %r10d, %r10d - LONG $0x00758e0f; WORD $0x0000 // jle LBB39_20, $117(%rip) - WORD $0x8b48; BYTE $0x07 // movq (%rdi), %rax - WORD $0x8944; BYTE $0xd1 // movl %r10d, %ecx - WORD $0x9090 // .p2align 4, 0x90 + LONG $0x0045840f; WORD $0x0000 // je LBB34_21, $69(%rip) -LBB39_18: - LONG $0xff518d48 // leaq $-1(%rcx), %rdx - WORD $0xd689 // movl %edx, %esi - LONG $0x30303c80 // cmpb $48, (%rax,%rsi) - LONG $0x0063850f; WORD $0x0000 // jne LBB39_22, $99(%rip) - WORD $0xc9ff // decl %ecx - WORD $0x4f89; BYTE $0x10 // movl %ecx, $16(%rdi) - LONG $0x01728d48 // leaq $1(%rdx), %rsi - WORD $0x8948; BYTE $0xd1 // movq %rdx, %rcx - LONG $0x01fe8348 // cmpq $1, %rsi - LONG $0xffda870f; WORD $0xffff // ja LBB39_18, $-38(%rip) - LONG $0x00004be9; BYTE $0x00 // jmp LBB39_21, $75(%rip) +LBB34_22: + BYTE $0x5b // popq %rbx + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq -LBB39_2: +LBB34_2: WORD $0x8548; BYTE $0xc0 // testq %rax, %rax - LONG $0x004c840f; WORD $0x0000 // je LBB39_23, $76(%rip) + LONG $0x0043840f; WORD $0x0000 // je LBB34_23, $67(%rip) QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90 WORD $0x8948; BYTE $0xc2 // movq %rax, %rdx WORD $0xd348; BYTE $0xea // shrq %cl, %rdx WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx - LONG $0xfed3850f; WORD $0xffff // jne LBB39_7, $-301(%rip) + LONG $0xfed0850f; WORD $0xffff // jne LBB34_7, $-304(%rip) -LBB39_4: +LBB34_4: WORD $0x0148; BYTE $0xc0 // addq %rax, %rax LONG $0x80048d48 // leaq (%rax,%rax,4), %rax WORD $0xff41; BYTE $0xc3 // incl %r11d WORD $0x8948; BYTE $0xc2 // movq %rax, %rdx WORD $0xd348; BYTE $0xea // shrq %cl, %rdx WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx - LONG $0xffe7840f; WORD $0xffff // je LBB39_4, $-25(%rip) - LONG $0xfffeb5e9; BYTE $0xff // jmp LBB39_7, $-331(%rip) - -LBB39_20: - LONG $0x0003840f; WORD $0x0000 // je LBB39_21, $3(%rip) + LONG $0xffe7840f; WORD $0xffff // je LBB34_4, $-25(%rip) + LONG $0xfffeb2e9; BYTE $0xff // jmp LBB34_7, $-334(%rip) -LBB39_22: - BYTE $0x5b // popq %rbx - BYTE $0x5d // popq %rbp - BYTE $0xc3 // retq - -LBB39_21: +LBB34_21: LONG $0x001447c7; WORD $0x0000; BYTE $0x00 // movl $0, $20(%rdi) BYTE $0x5b // popq %rbx BYTE $0x5d // popq %rbp BYTE $0xc3 // retq -LBB39_23: - LONG $0x001047c7; WORD $0x0000; BYTE $0x00 // movl $0, $16(%rdi) - BYTE $0x5b // popq %rbx - BYTE $0x5d // popq %rbp - BYTE $0xc3 // retq - LONG $0x00000000; WORD $0x0000 // .p2align 4, 0x00 +LBB34_23: + LONG $0x001047c7; WORD $0x0000; BYTE $0x00 // movl $0, $16(%rdi) + BYTE $0x5b // popq %rbx + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + QUAD $0x0000000000000000; LONG $0x00000000; WORD $0x0000; BYTE $0x00 // .p2align 4, 0x00 -LCPI40_0: +LCPI35_0: QUAD $0x2222222222222222; QUAD $0x2222222222222222 // .space 16, '""""""""""""""""' -LCPI40_1: +LCPI35_1: QUAD $0x5c5c5c5c5c5c5c5c; QUAD $0x5c5c5c5c5c5c5c5c // .space 16, '\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' // .p2align 4, 0x90 @@ -10159,103 +10470,106 @@ _advance_string_default: BYTE $0x50 // pushq %rax LONG $0x087f8b4c // movq $8(%rdi), %r15 WORD $0x2949; BYTE $0xf7 // subq %rsi, %r15 - LONG $0x0364840f; WORD $0x0000 // je LBB40_17, $868(%rip) - WORD $0x8b4c; BYTE $0x0f // movq (%rdi), %r9 + LONG $0x0327840f; WORD $0x0000 // je LBB35_13, $807(%rip) + WORD $0x8b4c; BYTE $0x1f // movq (%rdi), %r11 + WORD $0x014c; BYTE $0xde // addq %r11, %rsi LONG $0xff02c748; WORD $0xffff; BYTE $0xff // movq $-1, (%rdx) LONG $0x40ff8349 // cmpq $64, %r15 - LONG $0x01de820f; WORD $0x0000 // jb LBB40_18, $478(%rip) - WORD $0x8948; BYTE $0xf7 // movq %rsi, %rdi - WORD $0xf748; BYTE $0xd7 // notq %rdi + LONG $0x015f820f; WORD $0x0000 // jb LBB35_14, $351(%rip) QUAD $0xffffffffd045c748 // movq $-1, $-48(%rbp) WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d - QUAD $0xffffff98056ff9c5 // vmovdqa $-104(%rip), %xmm0 /* LCPI40_0(%rip) */ - QUAD $0xffffffa00d6ff9c5 // vmovdqa $-96(%rip), %xmm1 /* LCPI40_1(%rip) */ + QUAD $0xffffff9b056ff9c5 // vmovdqa $-101(%rip), %xmm0 /* LCPI35_0(%rip) */ + QUAD $0xffffffa30d6ff9c5 // vmovdqa $-93(%rip), %xmm1 /* LCPI35_1(%rip) */ + QUAD $0x555555555555ba49; WORD $0x5555 // movabsq $6148914691236517205, %r10 + QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90 - // .p2align 4, 0x90 -LBB40_3: - LONG $0x6f7ac1c4; WORD $0x3114 // vmovdqu (%r9,%rsi), %xmm2 - LONG $0x6f7ac1c4; WORD $0x315c; BYTE $0x10 // vmovdqu $16(%r9,%rsi), %xmm3 - LONG $0x6f7ac1c4; WORD $0x3164; BYTE $0x20 // vmovdqu $32(%r9,%rsi), %xmm4 - LONG $0x6f7ac1c4; WORD $0x316c; BYTE $0x30 // vmovdqu $48(%r9,%rsi), %xmm5 - LONG $0xf074e9c5 // vpcmpeqb %xmm0, %xmm2, %xmm6 - LONG $0xe6d779c5 // vpmovmskb %xmm6, %r12d - LONG $0xf074e1c5 // vpcmpeqb %xmm0, %xmm3, %xmm6 - LONG $0xc6d7f9c5 // vpmovmskb %xmm6, %eax - LONG $0xf074d9c5 // vpcmpeqb %xmm0, %xmm4, %xmm6 - LONG $0xc6d779c5 // vpmovmskb %xmm6, %r8d - LONG $0xf074d1c5 // vpcmpeqb %xmm0, %xmm5, %xmm6 - LONG $0xd6d779c5 // vpmovmskb %xmm6, %r10d - LONG $0xd174e9c5 // vpcmpeqb %xmm1, %xmm2, %xmm2 - LONG $0xead779c5 // vpmovmskb %xmm2, %r13d - LONG $0xd174e1c5 // vpcmpeqb %xmm1, %xmm3, %xmm2 - LONG $0xcad7f9c5 // vpmovmskb %xmm2, %ecx - LONG $0xd174d9c5 // vpcmpeqb %xmm1, %xmm4, %xmm2 - LONG $0xdad7f9c5 // vpmovmskb %xmm2, %ebx - LONG $0xd174d1c5 // vpcmpeqb %xmm1, %xmm5, %xmm2 - LONG $0xdad779c5 // vpmovmskb %xmm2, %r11d - LONG $0x30e2c149 // shlq $48, %r10 - LONG $0x20e0c149 // shlq $32, %r8 - WORD $0x094d; BYTE $0xd0 // orq %r10, %r8 - LONG $0x10e0c148 // shlq $16, %rax - WORD $0x094c; BYTE $0xc0 // orq %r8, %rax - WORD $0x0949; BYTE $0xc4 // orq %rax, %r12 - LONG $0x30e3c149 // shlq $48, %r11 - LONG $0x20e3c148 // shlq $32, %rbx - WORD $0x094c; BYTE $0xdb // orq %r11, %rbx - LONG $0x10e1c148 // shlq $16, %rcx - WORD $0x0948; BYTE $0xd9 // orq %rbx, %rcx - WORD $0x0949; BYTE $0xcd // orq %rcx, %r13 - LONG $0x0030850f; WORD $0x0000 // jne LBB40_7, $48(%rip) - WORD $0x854d; BYTE $0xf6 // testq %r14, %r14 - LONG $0x0040850f; WORD $0x0000 // jne LBB40_9, $64(%rip) - WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d - WORD $0x854d; BYTE $0xe4 // testq %r12, %r12 - LONG $0x0086850f; WORD $0x0000 // jne LBB40_10, $134(%rip) +LBB35_3: + LONG $0x166ffac5 // vmovdqu (%rsi), %xmm2 + LONG $0x5e6ffac5; BYTE $0x10 // vmovdqu $16(%rsi), %xmm3 + LONG $0x666ffac5; BYTE $0x20 // vmovdqu $32(%rsi), %xmm4 + LONG $0x6e6ffac5; BYTE $0x30 // vmovdqu $48(%rsi), %xmm5 + LONG $0xf074e9c5 // vpcmpeqb %xmm0, %xmm2, %xmm6 + LONG $0xe6d779c5 // vpmovmskb %xmm6, %r12d + LONG $0xf074e1c5 // vpcmpeqb %xmm0, %xmm3, %xmm6 + LONG $0xc6d7f9c5 // vpmovmskb %xmm6, %eax + LONG $0xf074d9c5 // vpcmpeqb %xmm0, %xmm4, %xmm6 + LONG $0xced7f9c5 // vpmovmskb %xmm6, %ecx + LONG $0xf074d1c5 // vpcmpeqb %xmm0, %xmm5, %xmm6 + LONG $0xfed7f9c5 // vpmovmskb %xmm6, %edi + LONG $0xd174e9c5 // vpcmpeqb %xmm1, %xmm2, %xmm2 + LONG $0xdad7f9c5 // vpmovmskb %xmm2, %ebx + LONG $0xd174e1c5 // vpcmpeqb %xmm1, %xmm3, %xmm2 + LONG $0xead779c5 // vpmovmskb %xmm2, %r13d + LONG $0xd174d9c5 // vpcmpeqb %xmm1, %xmm4, %xmm2 + LONG $0xc2d779c5 // vpmovmskb %xmm2, %r8d + LONG $0xd174d1c5 // vpcmpeqb %xmm1, %xmm5, %xmm2 + LONG $0xcad779c5 // vpmovmskb %xmm2, %r9d + LONG $0x30e7c148 // shlq $48, %rdi + LONG $0x20e1c148 // shlq $32, %rcx + LONG $0x10e0c148 // shlq $16, %rax + WORD $0x0949; BYTE $0xc4 // orq %rax, %r12 + WORD $0x0949; BYTE $0xcc // orq %rcx, %r12 + WORD $0x0949; BYTE $0xfc // orq %rdi, %r12 + LONG $0x30e1c149 // shlq $48, %r9 + LONG $0x20e0c149 // shlq $32, %r8 + LONG $0x10e5c149 // shlq $16, %r13 + WORD $0x094c; BYTE $0xeb // orq %r13, %rbx + WORD $0x094c; BYTE $0xc3 // orq %r8, %rbx + WORD $0x094c; BYTE $0xcb // orq %r9, %rbx + LONG $0x002c850f; WORD $0x0000 // jne LBB35_7, $44(%rip) + WORD $0x854d; BYTE $0xf6 // testq %r14, %r14 + LONG $0x0042850f; WORD $0x0000 // jne LBB35_9, $66(%rip) + WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d + WORD $0x854d; BYTE $0xe4 // testq %r12, %r12 + LONG $0x007e850f; WORD $0x0000 // jne LBB35_10, $126(%rip) -LBB40_6: - LONG $0xc0c78349 // addq $-64, %r15 - LONG $0xc0c78348 // addq $-64, %rdi +LBB35_6: LONG $0x40c68348 // addq $64, %rsi + LONG $0xc0c78349 // addq $-64, %r15 LONG $0x3fff8349 // cmpq $63, %r15 - LONG $0xff4a870f; WORD $0xffff // ja LBB40_3, $-182(%rip) - LONG $0x000081e9; BYTE $0x00 // jmp LBB40_12, $129(%rip) + LONG $0xff56870f; WORD $0xffff // ja LBB35_3, $-170(%rip) + LONG $0x00008de9; BYTE $0x00 // jmp LBB35_15, $141(%rip) -LBB40_7: +LBB35_7: LONG $0xd07d8348; BYTE $0xff // cmpq $-1, $-48(%rbp) - LONG $0x000e850f; WORD $0x0000 // jne LBB40_9, $14(%rip) - LONG $0xc5bc0f49 // bsfq %r13, %rax - WORD $0x0148; BYTE $0xf0 // addq %rsi, %rax - LONG $0xd0458948 // movq %rax, $-48(%rbp) - WORD $0x8948; BYTE $0x02 // movq %rax, (%rdx) + LONG $0x0014850f; WORD $0x0000 // jne LBB35_9, $20(%rip) + WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax + WORD $0x294c; BYTE $0xd8 // subq %r11, %rax + LONG $0xcbbc0f48 // bsfq %rbx, %rcx + WORD $0x0148; BYTE $0xc1 // addq %rax, %rcx + LONG $0xd04d8948 // movq %rcx, $-48(%rbp) + WORD $0x8948; BYTE $0x0a // movq %rcx, (%rdx) -LBB40_9: +LBB35_9: WORD $0x894c; BYTE $0xf0 // movq %r14, %rax WORD $0xf748; BYTE $0xd0 // notq %rax - WORD $0x214c; BYTE $0xe8 // andq %r13, %rax - LONG $0x00048d4c // leaq (%rax,%rax), %r8 - WORD $0x094d; BYTE $0xf0 // orq %r14, %r8 - WORD $0x894c; BYTE $0xc1 // movq %r8, %rcx - WORD $0xf748; BYTE $0xd1 // notq %rcx - WORD $0x214c; BYTE $0xe9 // andq %r13, %rcx + WORD $0x2148; BYTE $0xd8 // andq %rbx, %rax + LONG $0x000c8d48 // leaq (%rax,%rax), %rcx + WORD $0x094c; BYTE $0xf1 // orq %r14, %rcx + WORD $0x8948; BYTE $0xcf // movq %rcx, %rdi + WORD $0xf748; BYTE $0xd7 // notq %rdi + WORD $0x2148; BYTE $0xdf // andq %rbx, %rdi QUAD $0xaaaaaaaaaaaabb48; WORD $0xaaaa // movabsq $-6148914691236517206, %rbx - WORD $0x2148; BYTE $0xd9 // andq %rbx, %rcx + WORD $0x2148; BYTE $0xdf // andq %rbx, %rdi WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d - WORD $0x0148; BYTE $0xc1 // addq %rax, %rcx + WORD $0x0148; BYTE $0xc7 // addq %rax, %rdi LONG $0xc6920f41 // setb %r14b - WORD $0x0148; BYTE $0xc9 // addq %rcx, %rcx - QUAD $0x555555555555b848; WORD $0x5555 // movabsq $6148914691236517205, %rax - WORD $0x3148; BYTE $0xc1 // xorq %rax, %rcx - WORD $0x214c; BYTE $0xc1 // andq %r8, %rcx - WORD $0xf748; BYTE $0xd1 // notq %rcx - WORD $0x2149; BYTE $0xcc // andq %rcx, %r12 + WORD $0x0148; BYTE $0xff // addq %rdi, %rdi + WORD $0x314c; BYTE $0xd7 // xorq %r10, %rdi + WORD $0x2148; BYTE $0xcf // andq %rcx, %rdi + WORD $0xf748; BYTE $0xd7 // notq %rdi + WORD $0x2149; BYTE $0xfc // andq %rdi, %r12 WORD $0x854d; BYTE $0xe4 // testq %r12, %r12 - LONG $0xff7a840f; WORD $0xffff // je LBB40_6, $-134(%rip) + LONG $0xff82840f; WORD $0xffff // je LBB35_6, $-126(%rip) + +LBB35_10: + LONG $0xc4bc0f49 // bsfq %r12, %rax -LBB40_10: - LONG $0xc4bc0f49 // bsfq %r12, %rax - WORD $0x2948; BYTE $0xf8 // subq %rdi, %rax +LBB35_11: + WORD $0x294c; BYTE $0xde // subq %r11, %rsi + LONG $0x06448d48; BYTE $0x01 // leaq $1(%rsi,%rax), %rax -LBB40_11: +LBB35_12: LONG $0x08c48348 // addq $8, %rsp BYTE $0x5b // popq %rbx WORD $0x5c41 // popq %r12 @@ -10265,403 +10579,144 @@ LBB40_11: BYTE $0x5d // popq %rbp BYTE $0xc3 // retq -LBB40_12: - WORD $0x014c; BYTE $0xce // addq %r9, %rsi - LONG $0x20ff8349 // cmpq $32, %r15 - LONG $0x00f1820f; WORD $0x0000 // jb LBB40_23, $241(%rip) +LBB35_14: + QUAD $0xffffffffd045c748 // movq $-1, $-48(%rbp) + WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d -LBB40_13: +LBB35_15: + LONG $0x20ff8349 // cmpq $32, %r15 + LONG $0x00cb820f; WORD $0x0000 // jb LBB35_24, $203(%rip) LONG $0x066ffac5 // vmovdqu (%rsi), %xmm0 LONG $0x4e6ffac5; BYTE $0x10 // vmovdqu $16(%rsi), %xmm1 - QUAD $0xfffffe36156ff9c5 // vmovdqa $-458(%rip), %xmm2 /* LCPI40_0(%rip) */ - QUAD $0xfffffe3e1d6ff9c5 // vmovdqa $-450(%rip), %xmm3 /* LCPI40_1(%rip) */ + QUAD $0xfffffe29156ff9c5 // vmovdqa $-471(%rip), %xmm2 /* LCPI35_0(%rip) */ + QUAD $0xfffffe311d6ff9c5 // vmovdqa $-463(%rip), %xmm3 /* LCPI35_1(%rip) */ LONG $0xe274f9c5 // vpcmpeqb %xmm2, %xmm0, %xmm4 LONG $0xfcd7f9c5 // vpmovmskb %xmm4, %edi LONG $0xd274f1c5 // vpcmpeqb %xmm2, %xmm1, %xmm2 - LONG $0xcad7f9c5 // vpmovmskb %xmm2, %ecx + LONG $0xc2d7f9c5 // vpmovmskb %xmm2, %eax LONG $0xc374f9c5 // vpcmpeqb %xmm3, %xmm0, %xmm0 - LONG $0xc0d7f9c5 // vpmovmskb %xmm0, %eax - LONG $0xc374f1c5 // vpcmpeqb %xmm3, %xmm1, %xmm0 LONG $0xd8d7f9c5 // vpmovmskb %xmm0, %ebx + LONG $0xc374f1c5 // vpcmpeqb %xmm3, %xmm1, %xmm0 + LONG $0xc8d7f9c5 // vpmovmskb %xmm0, %ecx + LONG $0x10e0c148 // shlq $16, %rax + WORD $0x0948; BYTE $0xc7 // orq %rax, %rdi LONG $0x10e1c148 // shlq $16, %rcx - WORD $0x0948; BYTE $0xcf // orq %rcx, %rdi - LONG $0x10e3c148 // shlq $16, %rbx - WORD $0x0948; BYTE $0xd8 // orq %rbx, %rax - LONG $0x0044850f; WORD $0x0000 // jne LBB40_19, $68(%rip) + WORD $0x0948; BYTE $0xcb // orq %rcx, %rbx + LONG $0x001e850f; WORD $0x0000 // jne LBB35_20, $30(%rip) WORD $0x854d; BYTE $0xf6 // testq %r14, %r14 - LONG $0x005a850f; WORD $0x0000 // jne LBB40_21, $90(%rip) + LONG $0x0034850f; WORD $0x0000 // jne LBB35_22, $52(%rip) WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d WORD $0x8548; BYTE $0xff // testq %rdi, %rdi - LONG $0x0087840f; WORD $0x0000 // je LBB40_22, $135(%rip) + LONG $0x0061840f; WORD $0x0000 // je LBB35_23, $97(%rip) -LBB40_16: +LBB35_19: LONG $0xc7bc0f48 // bsfq %rdi, %rax - WORD $0x294c; BYTE $0xce // subq %r9, %rsi - WORD $0x0148; BYTE $0xf0 // addq %rsi, %rax - WORD $0xff48; BYTE $0xc0 // incq %rax - LONG $0xffff70e9; BYTE $0xff // jmp LBB40_11, $-144(%rip) + LONG $0xffff69e9; BYTE $0xff // jmp LBB35_11, $-151(%rip) -LBB40_18: - WORD $0x014c; BYTE $0xce // addq %r9, %rsi - QUAD $0xffffffffd045c748 // movq $-1, $-48(%rbp) - WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d - LONG $0x20ff8349 // cmpq $32, %r15 - LONG $0xff74830f; WORD $0xffff // jae LBB40_13, $-140(%rip) - LONG $0x000060e9; BYTE $0x00 // jmp LBB40_23, $96(%rip) - -LBB40_19: +LBB35_20: LONG $0xd07d8348; BYTE $0xff // cmpq $-1, $-48(%rbp) - LONG $0x0014850f; WORD $0x0000 // jne LBB40_21, $20(%rip) - WORD $0x8948; BYTE $0xf1 // movq %rsi, %rcx - WORD $0x294c; BYTE $0xc9 // subq %r9, %rcx - LONG $0xd8bc0f48 // bsfq %rax, %rbx - WORD $0x0148; BYTE $0xcb // addq %rcx, %rbx - LONG $0xd05d8948 // movq %rbx, $-48(%rbp) - WORD $0x8948; BYTE $0x1a // movq %rbx, (%rdx) + LONG $0x0014850f; WORD $0x0000 // jne LBB35_22, $20(%rip) + WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax + WORD $0x294c; BYTE $0xd8 // subq %r11, %rax + LONG $0xcbbc0f48 // bsfq %rbx, %rcx + WORD $0x0148; BYTE $0xc1 // addq %rax, %rcx + LONG $0xd04d8948 // movq %rcx, $-48(%rbp) + WORD $0x8948; BYTE $0x0a // movq %rcx, (%rdx) -LBB40_21: - WORD $0x8944; BYTE $0xf1 // movl %r14d, %ecx +LBB35_22: + WORD $0x8944; BYTE $0xf0 // movl %r14d, %eax + WORD $0xd0f7 // notl %eax + WORD $0xd821 // andl %ebx, %eax + LONG $0x46048d45 // leal (%r14,%rax,2), %r8d + WORD $0x0c8d; BYTE $0x00 // leal (%rax,%rax), %ecx WORD $0xd1f7 // notl %ecx - WORD $0xc121 // andl %eax, %ecx - WORD $0x1c8d; BYTE $0x09 // leal (%rcx,%rcx), %ebx - LONG $0x4e048d45 // leal (%r14,%rcx,2), %r8d - WORD $0xd3f7 // notl %ebx - WORD $0xc321 // andl %eax, %ebx - LONG $0xaaaae381; WORD $0xaaaa // andl $-1431655766, %ebx + WORD $0xd921 // andl %ebx, %ecx + LONG $0xaaaae181; WORD $0xaaaa // andl $-1431655766, %ecx WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d - WORD $0xcb01 // addl %ecx, %ebx + WORD $0xc101 // addl %eax, %ecx LONG $0xc6920f41 // setb %r14b - WORD $0xdb01 // addl %ebx, %ebx - LONG $0x5555f381; WORD $0x5555 // xorl $1431655765, %ebx - WORD $0x2144; BYTE $0xc3 // andl %r8d, %ebx - WORD $0xd3f7 // notl %ebx - WORD $0xdf21 // andl %ebx, %edi + WORD $0xc901 // addl %ecx, %ecx + LONG $0x5555f181; WORD $0x5555 // xorl $1431655765, %ecx + WORD $0x2144; BYTE $0xc1 // andl %r8d, %ecx + WORD $0xd1f7 // notl %ecx + WORD $0xcf21 // andl %ecx, %edi WORD $0x8548; BYTE $0xff // testq %rdi, %rdi - LONG $0xff79850f; WORD $0xffff // jne LBB40_16, $-135(%rip) + LONG $0xff9f850f; WORD $0xffff // jne LBB35_19, $-97(%rip) -LBB40_22: +LBB35_23: LONG $0x20c68348 // addq $32, %rsi LONG $0xe0c78349 // addq $-32, %r15 -LBB40_23: - WORD $0x854d; BYTE $0xf6 // testq %r14, %r14 - LONG $0x00b4850f; WORD $0x0000 // jne LBB40_38, $180(%rip) - WORD $0x854d; BYTE $0xff // testq %r15, %r15 - LONG $0x0088840f; WORD $0x0000 // je LBB40_35, $136(%rip) - -LBB40_25: - WORD $0x894c; BYTE $0xcf // movq %r9, %rdi - WORD $0xf748; BYTE $0xdf // negq %rdi +LBB35_24: + WORD $0x854d; BYTE $0xf6 // testq %r14, %r14 + LONG $0x0089850f; WORD $0x0000 // jne LBB35_35, $137(%rip) LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax + WORD $0x854d; BYTE $0xff // testq %r15, %r15 + LONG $0xfef8840f; WORD $0xffff // je LBB35_12, $-264(%rip) -LBB40_26: - WORD $0xdb31 // xorl %ebx, %ebx +LBB35_26: + WORD $0x894d; BYTE $0xd9 // movq %r11, %r9 + WORD $0xf749; BYTE $0xd1 // notq %r9 + +LBB35_27: + LONG $0x017e8d48 // leaq $1(%rsi), %rdi + WORD $0xb60f; BYTE $0x1e // movzbl (%rsi), %ebx + WORD $0xfb80; BYTE $0x22 // cmpb $34, %bl + LONG $0x0058840f; WORD $0x0000 // je LBB35_34, $88(%rip) + LONG $0xff578d4d // leaq $-1(%r15), %r10 + WORD $0xfb80; BYTE $0x5c // cmpb $92, %bl + LONG $0x0014840f; WORD $0x0000 // je LBB35_30, $20(%rip) + WORD $0x894d; BYTE $0xd7 // movq %r10, %r15 + WORD $0x8948; BYTE $0xfe // movq %rdi, %rsi + WORD $0x854d; BYTE $0xd2 // testq %r10, %r10 + LONG $0xffd4850f; WORD $0xffff // jne LBB35_27, $-44(%rip) + LONG $0xfffec1e9; BYTE $0xff // jmp LBB35_12, $-319(%rip) -LBB40_27: - LONG $0x1e0cb60f // movzbl (%rsi,%rbx), %ecx - WORD $0xf983; BYTE $0x22 // cmpl $34, %ecx - LONG $0x0066840f; WORD $0x0000 // je LBB40_34, $102(%rip) - WORD $0xf983; BYTE $0x5c // cmpl $92, %ecx - LONG $0x0011840f; WORD $0x0000 // je LBB40_30, $17(%rip) - WORD $0xff48; BYTE $0xc3 // incq %rbx - WORD $0x3949; BYTE $0xdf // cmpq %rbx, %r15 - LONG $0xffde850f; WORD $0xffff // jne LBB40_27, $-34(%rip) - LONG $0x00005de9; BYTE $0x00 // jmp LBB40_36, $93(%rip) - -LBB40_30: - LONG $0xff4f8d49 // leaq $-1(%r15), %rcx - WORD $0x3948; BYTE $0xd9 // cmpq %rbx, %rcx - LONG $0xfe9e840f; WORD $0xffff // je LBB40_11, $-354(%rip) +LBB35_30: + WORD $0x854d; BYTE $0xd2 // testq %r10, %r10 + LONG $0xfeb8840f; WORD $0xffff // je LBB35_12, $-328(%rip) LONG $0xd07d8348; BYTE $0xff // cmpq $-1, $-48(%rbp) - LONG $0x000e850f; WORD $0x0000 // jne LBB40_33, $14(%rip) - LONG $0x370c8d48 // leaq (%rdi,%rsi), %rcx - WORD $0x0148; BYTE $0xd9 // addq %rbx, %rcx - LONG $0xd04d8948 // movq %rcx, $-48(%rbp) - WORD $0x8948; BYTE $0x0a // movq %rcx, (%rdx) + LONG $0x000a850f; WORD $0x0000 // jne LBB35_33, $10(%rip) + WORD $0x014c; BYTE $0xcf // addq %r9, %rdi + WORD $0x8948; BYTE $0x3a // movq %rdi, (%rdx) + LONG $0xd07d8948 // movq %rdi, $-48(%rbp) -LBB40_33: - WORD $0x0148; BYTE $0xde // addq %rbx, %rsi +LBB35_33: LONG $0x02c68348 // addq $2, %rsi - WORD $0x894c; BYTE $0xf9 // movq %r15, %rcx - WORD $0x2948; BYTE $0xd9 // subq %rbx, %rcx - LONG $0xfec18348 // addq $-2, %rcx LONG $0xfec78349 // addq $-2, %r15 - WORD $0x3949; BYTE $0xdf // cmpq %rbx, %r15 - WORD $0x8949; BYTE $0xcf // movq %rcx, %r15 - LONG $0xff90850f; WORD $0xffff // jne LBB40_26, $-112(%rip) - LONG $0xfffe5fe9; BYTE $0xff // jmp LBB40_11, $-417(%rip) - -LBB40_34: - WORD $0x0148; BYTE $0xde // addq %rbx, %rsi - WORD $0xff48; BYTE $0xc6 // incq %rsi - -LBB40_35: - WORD $0x294c; BYTE $0xce // subq %r9, %rsi - WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax - LONG $0xfffe4ee9; BYTE $0xff // jmp LBB40_11, $-434(%rip) + WORD $0x894d; BYTE $0xfa // movq %r15, %r10 + WORD $0x854d; BYTE $0xd2 // testq %r10, %r10 + LONG $0xff9d850f; WORD $0xffff // jne LBB35_27, $-99(%rip) + LONG $0xfffe8ae9; BYTE $0xff // jmp LBB35_12, $-374(%rip) -LBB40_36: - LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax - WORD $0xf980; BYTE $0x22 // cmpb $34, %cl - LONG $0xfe3e850f; WORD $0xffff // jne LBB40_11, $-450(%rip) - WORD $0x0148; BYTE $0xde // addq %rbx, %rsi - LONG $0xffffdde9; BYTE $0xff // jmp LBB40_35, $-35(%rip) +LBB35_34: + WORD $0x294c; BYTE $0xdf // subq %r11, %rdi + WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax + LONG $0xfffe7fe9; BYTE $0xff // jmp LBB35_12, $-385(%rip) -LBB40_38: +LBB35_35: WORD $0x854d; BYTE $0xff // testq %r15, %r15 - LONG $0x002f840f; WORD $0x0000 // je LBB40_17, $47(%rip) + LONG $0x0036840f; WORD $0x0000 // je LBB35_13, $54(%rip) LONG $0xd07d8348; BYTE $0xff // cmpq $-1, $-48(%rbp) - LONG $0x0010850f; WORD $0x0000 // jne LBB40_41, $16(%rip) - WORD $0x894c; BYTE $0xc8 // movq %r9, %rax + LONG $0x0010850f; WORD $0x0000 // jne LBB35_38, $16(%rip) + WORD $0x894c; BYTE $0xd8 // movq %r11, %rax WORD $0xf748; BYTE $0xd0 // notq %rax WORD $0x0148; BYTE $0xf0 // addq %rsi, %rax LONG $0xd0458948 // movq %rax, $-48(%rbp) WORD $0x8948; BYTE $0x02 // movq %rax, (%rdx) -LBB40_41: - WORD $0xff48; BYTE $0xc6 // incq %rsi - WORD $0xff49; BYTE $0xcf // decq %r15 - WORD $0x854d; BYTE $0xff // testq %r15, %r15 - LONG $0xff22850f; WORD $0xffff // jne LBB40_25, $-222(%rip) - LONG $0xffffa5e9; BYTE $0xff // jmp LBB40_35, $-91(%rip) - -LBB40_17: +LBB35_38: + WORD $0xff48; BYTE $0xc6 // incq %rsi + WORD $0xff49; BYTE $0xcf // decq %r15 LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax - LONG $0xfffdf2e9; BYTE $0xff // jmp LBB40_11, $-526(%rip) - LONG $0x00000000; BYTE $0x00 // .p2align 4, 0x00 - -LCPI41_0: - BYTE $0xf0 // .byte 240 - BYTE $0x80 // .byte 128 - BYTE $0x80 // .byte 128 - BYTE $0x80 // .byte 128 - BYTE $0x00 // .space 1, '\x00' - BYTE $0x00 // .space 1, '\x00' - BYTE $0x00 // .space 1, '\x00' - BYTE $0x00 // .space 1, '\x00' - BYTE $0x00 // .space 1, '\x00' - BYTE $0x00 // .space 1, '\x00' - BYTE $0x00 // .space 1, '\x00' - BYTE $0x00 // .space 1, '\x00' - BYTE $0x00 // .space 1, '\x00' - BYTE $0x00 // .space 1, '\x00' - BYTE $0x00 // .space 1, '\x00' - BYTE $0x00 // .space 1, '\x00' - - // .p2align 4, 0x90 -_unescape: - BYTE $0x55 // pushq %rbp - WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp - WORD $0x5741 // pushq %r15 - WORD $0x5641 // pushq %r14 - WORD $0x5541 // pushq %r13 - WORD $0x5441 // pushq %r12 - BYTE $0x53 // pushq %rbx - LONG $0x18ec8348 // subq $24, %rsp - WORD $0x8b4c; BYTE $0x2f // movq (%rdi), %r13 - WORD $0x294c; BYTE $0xee // subq %r13, %rsi - LONG $0xffc3c748; WORD $0xffff; BYTE $0xff // movq $-1, %rbx - WORD $0x8548; BYTE $0xf6 // testq %rsi, %rsi - LONG $0x00d38e0f; WORD $0x0000 // jle LBB41_13, $211(%rip) - WORD $0x8949; BYTE $0xd6 // movq %rdx, %r14 - WORD $0x8949; BYTE $0xff // movq %rdi, %r15 - LONG $0x01458d49 // leaq $1(%r13), %rax - LONG $0x4db60f41; BYTE $0x01 // movzbl $1(%r13), %ecx - LONG $0x53158d48; WORD $0x0077; BYTE $0x00 // leaq $30547(%rip), %rdx /* __UnquoteTab(%rip) */ - LONG $0x110cb60f // movzbl (%rcx,%rdx), %ecx - LONG $0x00fff981; WORD $0x0000 // cmpl $255, %ecx - LONG $0x0017840f; WORD $0x0000 // je LBB41_4, $23(%rip) - WORD $0xc985 // testl %ecx, %ecx - LONG $0x0021850f; WORD $0x0000 // jne LBB41_6, $33(%rip) - WORD $0x8949; BYTE $0x07 // movq %rax, (%r15) - LONG $0xfdc3c748; WORD $0xffff; BYTE $0xff // movq $-3, %rbx - LONG $0x000096e9; BYTE $0x00 // jmp LBB41_13, $150(%rip) - -LBB41_4: - LONG $0x03fe8348 // cmpq $3, %rsi - LONG $0x0019870f; WORD $0x0000 // ja LBB41_7, $25(%rip) - WORD $0x8949; BYTE $0x07 // movq %rax, (%r15) - LONG $0x000084e9; BYTE $0x00 // jmp LBB41_13, $132(%rip) - -LBB41_6: - WORD $0x8841; BYTE $0x0e // movb %cl, (%r14) - LONG $0x02078349 // addq $2, (%r15) - LONG $0x000001bb; BYTE $0x00 // movl $1, %ebx - LONG $0x000073e9; BYTE $0x00 // jmp LBB41_13, $115(%rip) - -LBB41_7: - LONG $0x024d8b41 // movl $2(%r13), %ecx - WORD $0xc889 // movl %ecx, %eax - WORD $0xd0f7 // notl %eax - LONG $0xcfd0918d; WORD $0xcfcf // leal $-808464432(%rcx), %edx - LONG $0x80808025; BYTE $0x80 // andl $-2139062144, %eax - WORD $0xd085 // testl %edx, %eax - LONG $0x004a850f; WORD $0x0000 // jne LBB41_11, $74(%rip) - LONG $0x1919918d; WORD $0x1919 // leal $421075225(%rcx), %edx - WORD $0xca09 // orl %ecx, %edx - LONG $0x8080c2f7; WORD $0x8080 // testl $-2139062144, %edx - LONG $0x0036850f; WORD $0x0000 // jne LBB41_11, $54(%rip) - WORD $0xca89 // movl %ecx, %edx - LONG $0x7f7fe281; WORD $0x7f7f // andl $2139062143, %edx - LONG $0xc0c0c0bf; BYTE $0xc0 // movl $-1061109568, %edi - WORD $0xd729 // subl %edx, %edi - LONG $0x46469a8d; WORD $0x4646 // leal $1179010630(%rdx), %ebx - WORD $0xc721 // andl %eax, %edi - WORD $0xdf85 // testl %ebx, %edi - LONG $0x0017850f; WORD $0x0000 // jne LBB41_11, $23(%rip) - LONG $0xe0e0e0bf; BYTE $0xe0 // movl $-522133280, %edi - WORD $0xd729 // subl %edx, %edi - LONG $0x3939c281; WORD $0x3939 // addl $960051513, %edx - WORD $0xf821 // andl %edi, %eax - WORD $0xd085 // testl %edx, %eax - LONG $0x0020840f; WORD $0x0000 // je LBB41_14, $32(%rip) - -LBB41_11: - LONG $0x02c58349 // addq $2, %r13 - WORD $0x894d; BYTE $0x2f // movq %r13, (%r15) - -LBB41_12: - LONG $0xfec3c748; WORD $0xffff; BYTE $0xff // movq $-2, %rbx - -LBB41_13: - WORD $0x8948; BYTE $0xd8 // movq %rbx, %rax - LONG $0x18c48348 // addq $24, %rsp - BYTE $0x5b // popq %rbx - WORD $0x5c41 // popq %r12 - WORD $0x5d41 // popq %r13 - WORD $0x5e41 // popq %r14 - WORD $0x5f41 // popq %r15 - BYTE $0x5d // popq %rbp - BYTE $0xc3 // retq - -LBB41_14: - WORD $0xc90f // bswapl %ecx - WORD $0xc889 // movl %ecx, %eax - WORD $0xd0f7 // notl %eax - WORD $0xe8c1; BYTE $0x04 // shrl $4, %eax - LONG $0x01010125; BYTE $0x01 // andl $16843009, %eax - WORD $0x048d; BYTE $0xc0 // leal (%rax,%rax,8), %eax - LONG $0x0f0fe181; WORD $0x0f0f // andl $252645135, %ecx - WORD $0xc101 // addl %eax, %ecx - WORD $0xc889 // movl %ecx, %eax - WORD $0xe8c1; BYTE $0x04 // shrl $4, %eax - WORD $0xc809 // orl %ecx, %eax - WORD $0xc189 // movl %eax, %ecx - WORD $0xe9c1; BYTE $0x08 // shrl $8, %ecx - LONG $0xff00e181; WORD $0x0000 // andl $65280, %ecx - LONG $0xe0b60f44 // movzbl %al, %r12d - WORD $0x0941; BYTE $0xcc // orl %ecx, %r12d - LONG $0x06558d49 // leaq $6(%r13), %rdx - WORD $0x8949; BYTE $0x17 // movq %rdx, (%r15) - LONG $0x7ffc8341 // cmpl $127, %r12d - LONG $0x004c860f; WORD $0x0000 // jbe LBB41_18, $76(%rip) - LONG $0xfffc8141; WORD $0x0007; BYTE $0x00 // cmpl $2047, %r12d - LONG $0x004c860f; WORD $0x0000 // jbe LBB41_19, $76(%rip) - QUAD $0xffff200024bc8d41 // leal $-57344(%r12), %edi - LONG $0xf7ffff81; WORD $0xffff // cmpl $-2049, %edi - LONG $0x0055870f; WORD $0x0000 // ja LBB41_20, $85(%rip) - WORD $0xe9c1; BYTE $0x0c // shrl $12, %ecx - WORD $0xc980; BYTE $0xe0 // orb $-32, %cl - WORD $0x8841; BYTE $0x0e // movb %cl, (%r14) - LONG $0x06ecc141 // shrl $6, %r12d - LONG $0x3fe48041 // andb $63, %r12b - LONG $0x80cc8041 // orb $-128, %r12b - LONG $0x01668845 // movb %r12b, $1(%r14) - WORD $0x3f24 // andb $63, %al - WORD $0x800c // orb $-128, %al - LONG $0x02468841 // movb %al, $2(%r14) - LONG $0x000003bb; BYTE $0x00 // movl $3, %ebx - LONG $0xffff5fe9; BYTE $0xff // jmp LBB41_13, $-161(%rip) - -LBB41_18: - WORD $0x8841; BYTE $0x06 // movb %al, (%r14) - LONG $0x000001bb; BYTE $0x00 // movl $1, %ebx - LONG $0xffff52e9; BYTE $0xff // jmp LBB41_13, $-174(%rip) - -LBB41_19: - LONG $0x06ecc141 // shrl $6, %r12d - LONG $0xc0cc8041 // orb $-64, %r12b - WORD $0x8845; BYTE $0x26 // movb %r12b, (%r14) - WORD $0x3f24 // andb $63, %al - WORD $0x800c // orb $-128, %al - LONG $0x01468841 // movb %al, $1(%r14) - LONG $0x000002bb; BYTE $0x00 // movl $2, %ebx - LONG $0xffff35e9; BYTE $0xff // jmp LBB41_13, $-203(%rip) - -LBB41_20: - LONG $0xfcc3c748; WORD $0xffff; BYTE $0xff // movq $-4, %rbx - LONG $0x06fe8348 // cmpq $6, %rsi - LONG $0xff24820f; WORD $0xffff // jb LBB41_13, $-220(%rip) - LONG $0xfffc8141; WORD $0x00db; BYTE $0x00 // cmpl $56319, %r12d - LONG $0xff17870f; WORD $0xffff // ja LBB41_13, $-233(%rip) - WORD $0x3a80; BYTE $0x5c // cmpb $92, (%rdx) - LONG $0xff0e850f; WORD $0xffff // jne LBB41_13, $-242(%rip) - LONG $0x077d8041; BYTE $0x75 // cmpb $117, $7(%r13) - LONG $0xff03850f; WORD $0xffff // jne LBB41_13, $-253(%rip) - LONG $0x08458d49 // leaq $8(%r13), %rax - LONG $0xc8458948 // movq %rax, $-56(%rbp) - LONG $0x087d8b41 // movl $8(%r13), %edi - WORD $0x7d89; BYTE $0xd4 // movl %edi, $-44(%rbp) - LONG $0xff9875e8; BYTE $0xff // callq _unhex16_is, $-26507(%rip) - WORD $0xc084 // testb %al, %al - LONG $0x004f840f; WORD $0x0000 // je LBB41_27, $79(%rip) - WORD $0x4d8b; BYTE $0xd4 // movl $-44(%rbp), %ecx - WORD $0xc90f // bswapl %ecx - WORD $0xc889 // movl %ecx, %eax - WORD $0xd0f7 // notl %eax - WORD $0xe8c1; BYTE $0x04 // shrl $4, %eax - LONG $0x01010125; BYTE $0x01 // andl $16843009, %eax - WORD $0x048d; BYTE $0xc0 // leal (%rax,%rax,8), %eax - LONG $0x0f0fe181; WORD $0x0f0f // andl $252645135, %ecx - WORD $0xc101 // addl %eax, %ecx - WORD $0xc889 // movl %ecx, %eax - WORD $0xe8c1; BYTE $0x04 // shrl $4, %eax - WORD $0xc809 // orl %ecx, %eax - WORD $0xb60f; BYTE $0xc8 // movzbl %al, %ecx - WORD $0xe8c1; BYTE $0x08 // shrl $8, %eax - LONG $0x00ff0025; BYTE $0x00 // andl $65280, %eax - WORD $0x148d; BYTE $0x08 // leal (%rax,%rcx), %edx - LONG $0x2000c281; WORD $0xffff // addl $-57344, %edx - LONG $0xfbfffa81; WORD $0xffff // cmpl $-1025, %edx - LONG $0x0018870f; WORD $0x0000 // ja LBB41_28, $24(%rip) - LONG $0xc8458b48 // movq $-56(%rbp), %rax - WORD $0x8949; BYTE $0x07 // movq %rax, (%r15) - LONG $0xfffe98e9; BYTE $0xff // jmp LBB41_13, $-360(%rip) + WORD $0x854d; BYTE $0xff // testq %r15, %r15 + LONG $0xff4d850f; WORD $0xffff // jne LBB35_26, $-179(%rip) + LONG $0xfffe40e9; BYTE $0xff // jmp LBB35_12, $-448(%rip) -LBB41_27: - LONG $0xc8458b48 // movq $-56(%rbp), %rax - WORD $0x8949; BYTE $0x07 // movq %rax, (%r15) - LONG $0xfffe85e9; BYTE $0xff // jmp LBB41_12, $-379(%rip) - -LBB41_28: - WORD $0xc809 // orl %ecx, %eax - LONG $0x0ae4c141 // shll $10, %r12d - WORD $0xc189 // movl %eax, %ecx - WORD $0x0144; BYTE $0xe1 // addl %r12d, %ecx - WORD $0x0144; BYTE $0xe0 // addl %r12d, %eax - LONG $0xa0240005; BYTE $0xfc // addl $-56613888, %eax - WORD $0xc289 // movl %eax, %edx - WORD $0xeac1; BYTE $0x12 // shrl $18, %edx - WORD $0xc689 // movl %eax, %esi - WORD $0xeec1; BYTE $0x0c // shrl $12, %esi - LONG $0x3fe68040 // andb $63, %sil - WORD $0xe8c1; BYTE $0x06 // shrl $6, %eax - WORD $0x3f24 // andb $63, %al - WORD $0xe180; BYTE $0x3f // andb $63, %cl - LONG $0xc26ef9c5 // vmovd %edx, %xmm0 - LONG $0xd6b60f40 // movzbl %sil, %edx - LONG $0x2079e3c4; WORD $0x01c2 // vpinsrb $1, %edx, %xmm0, %xmm0 - WORD $0xb60f; BYTE $0xc0 // movzbl %al, %eax - LONG $0x2079e3c4; WORD $0x02c0 // vpinsrb $2, %eax, %xmm0, %xmm0 - WORD $0xb60f; BYTE $0xc1 // movzbl %cl, %eax - LONG $0x2079e3c4; WORD $0x03c0 // vpinsrb $3, %eax, %xmm0, %xmm0 - QUAD $0xfffffd3105ebf9c5 // vpor $-719(%rip), %xmm0, %xmm0 /* LCPI41_0(%rip) */ - LONG $0x7e79c1c4; BYTE $0x06 // vmovd %xmm0, (%r14) - LONG $0x0cc58349 // addq $12, %r13 - WORD $0x894d; BYTE $0x2f // movq %r13, (%r15) - LONG $0x000004bb; BYTE $0x00 // movl $4, %ebx - LONG $0xfffe25e9; BYTE $0xff // jmp LBB41_13, $-475(%rip) - QUAD $0x0000000000000000; WORD $0x0000; BYTE $0x00 // .p2align 4, 0x00 +LBB35_13: + LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax + LONG $0xfffe34e9; BYTE $0xff // jmp LBB35_12, $-460(%rip) + WORD $0x0000 // .p2align 4, 0x00 _POW10_M128_TAB: QUAD $0x1732c869cd60e453 // .quad 1671618768450675795 @@ -12090,7 +12145,7 @@ _Digits: QUAD $0x3939383937393639 // .ascii 8, '96979899' QUAD $0x0000000000000000 // .p2align 4, 0x00 -_LB_cf971573: // _pow10_ceil_sig.g +_LB_1ee00aeb: // _pow10_ceil_sig.g QUAD $0xff77b1fcbebcdc4f // .quad -38366372719436721 QUAD $0x25e8e89c13bb0f7b // .quad 2731688931043774331 QUAD $0x9faacf3df73609b1 // .quad -6941508010590729807 @@ -14745,7 +14800,7 @@ _P10_TAB: QUAD $0x4480f0cf064dd592 // .quad 0x4480f0cf064dd592 QUAD $0x0000000000000000 // .p2align 4, 0x00 -_LB_ff7ea7df: // _pow10_ceil_sig_f32.g +_LB_5bf8fe43: // _pow10_ceil_sig_f32.g QUAD $0x81ceb32c4b43fcf5 // .quad -9093133594791772939 QUAD $0xa2425ff75e14fc32 // .quad -6754730975062328270 QUAD $0xcad2f7f5359a3b3f // .quad -3831727700400522433 @@ -14829,14 +14884,14 @@ TEXT ·__f32toa(SB), NOSPLIT | NOFRAME, $0 - 24 _entry: MOVQ (TLS), R14 - LEAQ -56(SP), R12 + LEAQ -48(SP), R12 CMPQ R12, 16(R14) JBE _stack_grow _f32toa: MOVQ out+0(FP), DI MOVSD val+8(FP), X0 - CALL ·__native_entry__+29744(SB) // _f32toa + CALL ·__native_entry__+31264(SB) // _f32toa MOVQ AX, ret+16(FP) RET @@ -14856,7 +14911,7 @@ _entry: _f64toa: MOVQ out+0(FP), DI MOVSD val+8(FP), X0 - CALL ·__native_entry__+496(SB) // _f64toa + CALL ·__native_entry__+192(SB) // _f64toa MOVQ AX, ret+16(FP) RET @@ -14864,12 +14919,12 @@ _stack_grow: CALL runtime·morestack_noctxt<>(SB) JMP _entry -TEXT ·__get_by_path(SB), NOSPLIT | NOFRAME, $0 - 32 +TEXT ·__get_by_path(SB), NOSPLIT | NOFRAME, $0 - 40 NO_LOCAL_POINTERS _entry: MOVQ (TLS), R14 - LEAQ -312(SP), R12 + LEAQ -304(SP), R12 CMPQ R12, 16(R14) JBE _stack_grow @@ -14877,8 +14932,9 @@ _get_by_path: MOVQ s+0(FP), DI MOVQ p+8(FP), SI MOVQ path+16(FP), DX - CALL ·__native_entry__+27424(SB) // _get_by_path - MOVQ AX, ret+24(FP) + MOVQ m+24(FP), CX + CALL ·__native_entry__+25856(SB) // _get_by_path + MOVQ AX, ret+32(FP) RET _stack_grow: @@ -14899,7 +14955,7 @@ _html_escape: MOVQ nb+8(FP), SI MOVQ dp+16(FP), DX MOVQ dn+24(FP), CX - CALL ·__native_entry__+9968(SB) // _html_escape + CALL ·__native_entry__+9040(SB) // _html_escape MOVQ AX, ret+32(FP) RET @@ -14919,7 +14975,7 @@ _entry: _i64toa: MOVQ out+0(FP), DI MOVQ val+8(FP), SI - CALL ·__native_entry__+4112(SB) // _i64toa + CALL ·__native_entry__+3488(SB) // _i64toa MOVQ AX, ret+16(FP) RET @@ -14940,7 +14996,7 @@ _lspace: MOVQ sp+0(FP), DI MOVQ nb+8(FP), SI MOVQ off+16(FP), DX - CALL ·__native_entry__+80(SB) // _lspace + CALL ·__native_entry__+16(SB) // _lspace MOVQ AX, ret+24(FP) RET @@ -14953,7 +15009,7 @@ TEXT ·__quote(SB), NOSPLIT | NOFRAME, $0 - 48 _entry: MOVQ (TLS), R14 - LEAQ -80(SP), R12 + LEAQ -56(SP), R12 CMPQ R12, 16(R14) JBE _stack_grow @@ -14963,7 +15019,7 @@ _quote: MOVQ dp+16(FP), DX MOVQ dn+24(FP), CX MOVQ flags+32(FP), R8 - CALL ·__native_entry__+5792(SB) // _quote + CALL ·__native_entry__+4880(SB) // _quote MOVQ AX, ret+40(FP) RET @@ -14985,7 +15041,7 @@ _skip_array: MOVQ p+8(FP), SI MOVQ m+16(FP), DX MOVQ flags+24(FP), CX - CALL ·__native_entry__+20576(SB) // _skip_array + CALL ·__native_entry__+17952(SB) // _skip_array MOVQ AX, ret+32(FP) RET @@ -15005,7 +15061,7 @@ _entry: _skip_number: MOVQ s+0(FP), DI MOVQ p+8(FP), SI - CALL ·__native_entry__+23920(SB) // _skip_number + CALL ·__native_entry__+21952(SB) // _skip_number MOVQ AX, ret+16(FP) RET @@ -15027,7 +15083,7 @@ _skip_object: MOVQ p+8(FP), SI MOVQ m+16(FP), DX MOVQ flags+24(FP), CX - CALL ·__native_entry__+22496(SB) // _skip_object + CALL ·__native_entry__+20368(SB) // _skip_object MOVQ AX, ret+32(FP) RET @@ -15049,7 +15105,7 @@ _skip_one: MOVQ p+8(FP), SI MOVQ m+16(FP), DX MOVQ flags+24(FP), CX - CALL ·__native_entry__+24080(SB) // _skip_one + CALL ·__native_entry__+22112(SB) // _skip_one MOVQ AX, ret+32(FP) RET @@ -15062,14 +15118,14 @@ TEXT ·__skip_one_fast(SB), NOSPLIT | NOFRAME, $0 - 24 _entry: MOVQ (TLS), R14 - LEAQ -208(SP), R12 + LEAQ -200(SP), R12 CMPQ R12, 16(R14) JBE _stack_grow _skip_one_fast: MOVQ s+0(FP), DI MOVQ p+8(FP), SI - CALL ·__native_entry__+24320(SB) // _skip_one_fast + CALL ·__native_entry__+22352(SB) // _skip_one_fast MOVQ AX, ret+16(FP) RET @@ -15089,7 +15145,7 @@ _entry: _u64toa: MOVQ out+0(FP), DI MOVQ val+8(FP), SI - CALL ·__native_entry__+4384(SB) // _u64toa + CALL ·__native_entry__+3600(SB) // _u64toa MOVQ AX, ret+16(FP) RET @@ -15102,7 +15158,7 @@ TEXT ·__unquote(SB), NOSPLIT | NOFRAME, $0 - 48 _entry: MOVQ (TLS), R14 - LEAQ -128(SP), R12 + LEAQ -88(SP), R12 CMPQ R12, 16(R14) JBE _stack_grow @@ -15112,7 +15168,7 @@ _unquote: MOVQ dp+16(FP), DX MOVQ ep+24(FP), CX MOVQ flags+32(FP), R8 - CALL ·__native_entry__+7488(SB) // _unquote + CALL ·__native_entry__+6672(SB) // _unquote MOVQ AX, ret+40(FP) RET @@ -15133,7 +15189,7 @@ _validate_one: MOVQ s+0(FP), DI MOVQ p+8(FP), SI MOVQ m+16(FP), DX - CALL ·__native_entry__+24144(SB) // _validate_one + CALL ·__native_entry__+22176(SB) // _validate_one MOVQ AX, ret+24(FP) RET @@ -15154,7 +15210,7 @@ _validate_utf8: MOVQ s+0(FP), DI MOVQ p+8(FP), SI MOVQ m+16(FP), DX - CALL ·__native_entry__+28464(SB) // _validate_utf8 + CALL ·__native_entry__+30000(SB) // _validate_utf8 MOVQ AX, ret+24(FP) RET @@ -15173,7 +15229,7 @@ _entry: _validate_utf8_fast: MOVQ s+0(FP), DI - CALL ·__native_entry__+29136(SB) // _validate_utf8_fast + CALL ·__native_entry__+30672(SB) // _validate_utf8_fast MOVQ AX, ret+8(FP) RET @@ -15186,7 +15242,7 @@ TEXT ·__value(SB), NOSPLIT | NOFRAME, $0 - 48 _entry: MOVQ (TLS), R14 - LEAQ -368(SP), R12 + LEAQ -328(SP), R12 CMPQ R12, 16(R14) JBE _stack_grow @@ -15196,7 +15252,7 @@ _value: MOVQ p+16(FP), DX MOVQ v+24(FP), CX MOVQ flags+32(FP), R8 - CALL ·__native_entry__+14672(SB) // _value + CALL ·__native_entry__+12224(SB) // _value MOVQ AX, ret+40(FP) RET @@ -15209,7 +15265,7 @@ TEXT ·__vnumber(SB), NOSPLIT | NOFRAME, $0 - 24 _entry: MOVQ (TLS), R14 - LEAQ -280(SP), R12 + LEAQ -240(SP), R12 CMPQ R12, 16(R14) JBE _stack_grow @@ -15217,7 +15273,7 @@ _vnumber: MOVQ s+0(FP), DI MOVQ p+8(FP), SI MOVQ v+16(FP), DX - LEAQ ·__native_entry__+18320(SB), AX // _vnumber + LEAQ ·__native_entry__+15616(SB), AX // _vnumber JMP AX _stack_grow: @@ -15237,7 +15293,7 @@ _vsigned: MOVQ s+0(FP), DI MOVQ p+8(FP), SI MOVQ v+16(FP), DX - LEAQ ·__native_entry__+19856(SB), AX // _vsigned + LEAQ ·__native_entry__+17232(SB), AX // _vsigned JMP AX _stack_grow: @@ -15249,7 +15305,7 @@ TEXT ·__vstring(SB), NOSPLIT | NOFRAME, $0 - 32 _entry: MOVQ (TLS), R14 - LEAQ -128(SP), R12 + LEAQ -136(SP), R12 CMPQ R12, 16(R14) JBE _stack_grow @@ -15258,7 +15314,7 @@ _vstring: MOVQ p+8(FP), SI MOVQ v+16(FP), DX MOVQ flags+24(FP), CX - LEAQ ·__native_entry__+16864(SB), AX // _vstring + LEAQ ·__native_entry__+14064(SB), AX // _vstring JMP AX _stack_grow: @@ -15270,7 +15326,7 @@ TEXT ·__vunsigned(SB), NOSPLIT | NOFRAME, $0 - 24 _entry: MOVQ (TLS), R14 - LEAQ -24(SP), R12 + LEAQ -16(SP), R12 CMPQ R12, 16(R14) JBE _stack_grow @@ -15278,7 +15334,7 @@ _vunsigned: MOVQ s+0(FP), DI MOVQ p+8(FP), SI MOVQ v+16(FP), DX - LEAQ ·__native_entry__+20208(SB), AX // _vunsigned + LEAQ ·__native_entry__+17600(SB), AX // _vunsigned JMP AX _stack_grow: diff --git a/vendor/github.com/bytedance/sonic/internal/native/avx/native_subr_amd64.go b/vendor/github.com/bytedance/sonic/internal/native/avx/native_subr_amd64.go index 34eaeb97c..f20095d3d 100644 --- a/vendor/github.com/bytedance/sonic/internal/native/avx/native_subr_amd64.go +++ b/vendor/github.com/bytedance/sonic/internal/native/avx/native_subr_amd64.go @@ -9,53 +9,53 @@ package avx func __native_entry__() uintptr var ( - _subr__f32toa = __native_entry__() + 29744 - _subr__f64toa = __native_entry__() + 496 - _subr__get_by_path = __native_entry__() + 27424 - _subr__html_escape = __native_entry__() + 9968 - _subr__i64toa = __native_entry__() + 4112 - _subr__lspace = __native_entry__() + 80 - _subr__quote = __native_entry__() + 5792 - _subr__skip_array = __native_entry__() + 20576 - _subr__skip_number = __native_entry__() + 23920 - _subr__skip_object = __native_entry__() + 22496 - _subr__skip_one = __native_entry__() + 24080 - _subr__skip_one_fast = __native_entry__() + 24320 - _subr__u64toa = __native_entry__() + 4384 - _subr__unquote = __native_entry__() + 7488 - _subr__validate_one = __native_entry__() + 24144 - _subr__validate_utf8 = __native_entry__() + 28464 - _subr__validate_utf8_fast = __native_entry__() + 29136 - _subr__value = __native_entry__() + 14672 - _subr__vnumber = __native_entry__() + 18320 - _subr__vsigned = __native_entry__() + 19856 - _subr__vstring = __native_entry__() + 16864 - _subr__vunsigned = __native_entry__() + 20208 + _subr__f32toa = __native_entry__() + 31264 + _subr__f64toa = __native_entry__() + 192 + _subr__get_by_path = __native_entry__() + 25856 + _subr__html_escape = __native_entry__() + 9040 + _subr__i64toa = __native_entry__() + 3488 + _subr__lspace = __native_entry__() + 16 + _subr__quote = __native_entry__() + 4880 + _subr__skip_array = __native_entry__() + 17952 + _subr__skip_number = __native_entry__() + 21952 + _subr__skip_object = __native_entry__() + 20368 + _subr__skip_one = __native_entry__() + 22112 + _subr__skip_one_fast = __native_entry__() + 22352 + _subr__u64toa = __native_entry__() + 3600 + _subr__unquote = __native_entry__() + 6672 + _subr__validate_one = __native_entry__() + 22176 + _subr__validate_utf8 = __native_entry__() + 30000 + _subr__validate_utf8_fast = __native_entry__() + 30672 + _subr__value = __native_entry__() + 12224 + _subr__vnumber = __native_entry__() + 15616 + _subr__vsigned = __native_entry__() + 17232 + _subr__vstring = __native_entry__() + 14064 + _subr__vunsigned = __native_entry__() + 17600 ) const ( - _stack__f32toa = 56 + _stack__f32toa = 48 _stack__f64toa = 80 - _stack__get_by_path = 312 + _stack__get_by_path = 304 _stack__html_escape = 64 _stack__i64toa = 16 _stack__lspace = 8 - _stack__quote = 80 + _stack__quote = 56 _stack__skip_array = 128 _stack__skip_number = 72 _stack__skip_object = 128 _stack__skip_one = 128 - _stack__skip_one_fast = 208 + _stack__skip_one_fast = 200 _stack__u64toa = 8 - _stack__unquote = 128 + _stack__unquote = 88 _stack__validate_one = 128 _stack__validate_utf8 = 48 _stack__validate_utf8_fast = 24 - _stack__value = 368 - _stack__vnumber = 280 + _stack__value = 328 + _stack__vnumber = 240 _stack__vsigned = 16 - _stack__vstring = 128 - _stack__vunsigned = 24 + _stack__vstring = 136 + _stack__vunsigned = 16 ) var ( diff --git a/vendor/github.com/bytedance/sonic/internal/native/avx2/native_amd64.go b/vendor/github.com/bytedance/sonic/internal/native/avx2/native_amd64.go index bf7c68683..bebd83c80 100644 --- a/vendor/github.com/bytedance/sonic/internal/native/avx2/native_amd64.go +++ b/vendor/github.com/bytedance/sonic/internal/native/avx2/native_amd64.go @@ -122,7 +122,7 @@ func __validate_one(s *string, p *int, m *types.StateMachine) (ret int) //go:nosplit //go:noescape //goland:noinspection GoUnusedParameter -func __get_by_path(s *string, p *int, path *[]interface{}) (ret int) +func __get_by_path(s *string, p *int, path *[]interface{}, m *types.StateMachine) (ret int) //go:nosplit //go:noescape diff --git a/vendor/github.com/bytedance/sonic/internal/native/avx2/native_amd64.s b/vendor/github.com/bytedance/sonic/internal/native/avx2/native_amd64.s index 198a06e92..07789ae4a 100644 --- a/vendor/github.com/bytedance/sonic/internal/native/avx2/native_amd64.s +++ b/vendor/github.com/bytedance/sonic/internal/native/avx2/native_amd64.s @@ -13,185 +13,109 @@ TEXT ·__native_entry__(SB), NOSPLIT, $0 QUAD $0x0000000000000000; QUAD $0x0000000000000000; WORD $0x0000; BYTE $0x00 // .p2align 5, 0x00 LCPI0_0: - QUAD $0x2020202020202020; QUAD $0x2020202020202020 // .space 16, ' ' - QUAD $0x2020202020202020; QUAD $0x2020202020202020 // .space 16, ' ' - -LCPI0_1: - QUAD $0x0909090909090909; QUAD $0x0909090909090909 // .space 16, '\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t' - QUAD $0x0909090909090909; QUAD $0x0909090909090909 // .space 16, '\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t' - -LCPI0_2: - QUAD $0x0a0a0a0a0a0a0a0a; QUAD $0x0a0a0a0a0a0a0a0a // .space 16, '\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n' - QUAD $0x0a0a0a0a0a0a0a0a; QUAD $0x0a0a0a0a0a0a0a0a // .space 16, '\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n' - -LCPI0_3: - QUAD $0x0d0d0d0d0d0d0d0d; QUAD $0x0d0d0d0d0d0d0d0d // .space 16, '\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r' - QUAD $0x0d0d0d0d0d0d0d0d; QUAD $0x0d0d0d0d0d0d0d0d // .space 16, '\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r' - - // .p2align 4, 0x00 -LCPI0_4: - QUAD $0x2020202020202020; QUAD $0x2020202020202020 // .space 16, ' ' - -LCPI0_5: - QUAD $0x0909090909090909; QUAD $0x0909090909090909 // .space 16, '\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t' - -LCPI0_6: - QUAD $0x0a0a0a0a0a0a0a0a; QUAD $0x0a0a0a0a0a0a0a0a // .space 16, '\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n' - -LCPI0_7: - QUAD $0x0d0d0d0d0d0d0d0d; QUAD $0x0d0d0d0d0d0d0d0d // .space 16, '\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r' + BYTE $0x20 // .byte 32 + BYTE $0x00 // .byte 0 + BYTE $0x00 // .byte 0 + BYTE $0x00 // .byte 0 + BYTE $0x00 // .byte 0 + BYTE $0x00 // .byte 0 + BYTE $0x00 // .byte 0 + BYTE $0x00 // .byte 0 + BYTE $0x00 // .byte 0 + BYTE $0x09 // .byte 9 + BYTE $0x0a // .byte 10 + BYTE $0x00 // .byte 0 + BYTE $0x00 // .byte 0 + BYTE $0x0d // .byte 13 + BYTE $0x00 // .byte 0 + BYTE $0x00 // .byte 0 + BYTE $0x20 // .byte 32 + BYTE $0x00 // .byte 0 + BYTE $0x00 // .byte 0 + BYTE $0x00 // .byte 0 + BYTE $0x00 // .byte 0 + BYTE $0x00 // .byte 0 + BYTE $0x00 // .byte 0 + BYTE $0x00 // .byte 0 + BYTE $0x00 // .byte 0 + BYTE $0x09 // .byte 9 + BYTE $0x0a // .byte 10 + BYTE $0x00 // .byte 0 + BYTE $0x00 // .byte 0 + BYTE $0x0d // .byte 13 + BYTE $0x00 // .byte 0 + BYTE $0x00 // .byte 0 // .p2align 4, 0x90 _lspace: - BYTE $0x55 // pushq %rbp - WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp - WORD $0x8948; BYTE $0xd0 // movq %rdx, %rax - LONG $0x17148d4c // leaq (%rdi,%rdx), %r10 - WORD $0x8948; BYTE $0xf2 // movq %rsi, %rdx - WORD $0x2948; BYTE $0xc2 // subq %rax, %rdx - LONG $0x0066840f; WORD $0x0000 // je LBB0_7, $102(%rip) - WORD $0x8944; BYTE $0xd1 // movl %r10d, %ecx - WORD $0xe183; BYTE $0x1f // andl $31, %ecx - LONG $0x005a840f; WORD $0x0000 // je LBB0_7, $90(%rip) - LONG $0x014f8d4c // leaq $1(%rdi), %r9 - LONG $0xff4e8d48 // leaq $-1(%rsi), %rcx - QUAD $0x000100002600b849; WORD $0x0000 // movabsq $4294977024, %r8 - QUAD $0x9090909090909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 - -LBB0_3: - LONG $0x0714be0f // movsbl (%rdi,%rax), %edx - WORD $0xfa83; BYTE $0x20 // cmpl $32, %edx - LONG $0x016e870f; WORD $0x0000 // ja LBB0_27, $366(%rip) - LONG $0xd0a30f49 // btq %rdx, %r8 - LONG $0x0164830f; WORD $0x0000 // jae LBB0_27, $356(%rip) - LONG $0x01508d48 // leaq $1(%rax), %rdx - WORD $0x3948; BYTE $0xc1 // cmpq %rax, %rcx - LONG $0x000f840f; WORD $0x0000 // je LBB0_6, $15(%rip) - WORD $0x0144; BYTE $0xc8 // addl %r9d, %eax - WORD $0xe083; BYTE $0x1f // andl $31, %eax - WORD $0x8948; BYTE $0xd0 // movq %rdx, %rax - LONG $0xffcd850f; WORD $0xffff // jne LBB0_3, $-51(%rip) - -LBB0_6: - LONG $0x17148d4c // leaq (%rdi,%rdx), %r10 - WORD $0x2948; BYTE $0xd6 // subq %rdx, %rsi - WORD $0x8948; BYTE $0xf2 // movq %rsi, %rdx - -LBB0_7: - LONG $0x20fa8348 // cmpq $32, %rdx - LONG $0x006d820f; WORD $0x0000 // jb LBB0_13, $109(%rip) - WORD $0x8948; BYTE $0xfe // movq %rdi, %rsi - WORD $0x294c; BYTE $0xd6 // subq %r10, %rsi - QUAD $0xfffffeab056ffdc5 // vmovdqa $-341(%rip), %ymm0 /* LCPI0_0(%rip) */ - QUAD $0xfffffec30d6ffdc5 // vmovdqa $-317(%rip), %ymm1 /* LCPI0_1(%rip) */ - QUAD $0xfffffedb156ffdc5 // vmovdqa $-293(%rip), %ymm2 /* LCPI0_2(%rip) */ - QUAD $0xfffffef31d6ffdc5 // vmovdqa $-269(%rip), %ymm3 /* LCPI0_3(%rip) */ + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + LONG $0x17048d48 // leaq (%rdi,%rdx), %rax + WORD $0x2948; BYTE $0xd6 // subq %rdx, %rsi + LONG $0x20fe8348 // cmpq $32, %rsi + LONG $0x0037820f; WORD $0x0000 // jb LBB0_5, $55(%rip) + QUAD $0xffffffc3056ffdc5 // vmovdqa $-61(%rip), %ymm0 /* LCPI0_0(%rip) */ WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 -LBB0_9: - LONG $0x6f7dc1c4; BYTE $0x22 // vmovdqa (%r10), %ymm4 - LONG $0xe874ddc5 // vpcmpeqb %ymm0, %ymm4, %ymm5 - LONG $0xf174ddc5 // vpcmpeqb %ymm1, %ymm4, %ymm6 - LONG $0xeeebd5c5 // vpor %ymm6, %ymm5, %ymm5 - LONG $0xf274ddc5 // vpcmpeqb %ymm2, %ymm4, %ymm6 - LONG $0xe374ddc5 // vpcmpeqb %ymm3, %ymm4, %ymm4 - LONG $0xe6ebddc5 // vpor %ymm6, %ymm4, %ymm4 - LONG $0xe5ebddc5 // vpor %ymm5, %ymm4, %ymm4 - LONG $0xc4d7fdc5 // vpmovmskb %ymm4, %eax - WORD $0xf883; BYTE $0xff // cmpl $-1, %eax - LONG $0x00df850f; WORD $0x0000 // jne LBB0_10, $223(%rip) - LONG $0x20c28349 // addq $32, %r10 - LONG $0xe0c28348 // addq $-32, %rdx +LBB0_2: + LONG $0x086ffec5 // vmovdqu (%rax), %ymm1 + LONG $0x007de2c4; BYTE $0xd1 // vpshufb %ymm1, %ymm0, %ymm2 + LONG $0xca74f5c5 // vpcmpeqb %ymm2, %ymm1, %ymm1 + LONG $0xc9d7fdc5 // vpmovmskb %ymm1, %ecx + WORD $0xf983; BYTE $0xff // cmpl $-1, %ecx + LONG $0x005d850f; WORD $0x0000 // jne LBB0_3, $93(%rip) + LONG $0x20c08348 // addq $32, %rax LONG $0xe0c68348 // addq $-32, %rsi - LONG $0x1ffa8348 // cmpq $31, %rdx - LONG $0xffbc870f; WORD $0xffff // ja LBB0_9, $-68(%rip) - -LBB0_13: - WORD $0xf8c5; BYTE $0x77 // vzeroupper - LONG $0x10fa8348 // cmpq $16, %rdx - LONG $0x0074820f; WORD $0x0000 // jb LBB0_18, $116(%rip) - WORD $0x8948; BYTE $0xfe // movq %rdi, %rsi - WORD $0x294c; BYTE $0xd6 // subq %r10, %rsi - QUAD $0xfffffeb1056ff9c5 // vmovdqa $-335(%rip), %xmm0 /* LCPI0_4(%rip) */ - QUAD $0xfffffeb90d6ff9c5 // vmovdqa $-327(%rip), %xmm1 /* LCPI0_5(%rip) */ - QUAD $0xfffffec1156ff9c5 // vmovdqa $-319(%rip), %xmm2 /* LCPI0_6(%rip) */ - QUAD $0xfffffec91d6ff9c5 // vmovdqa $-311(%rip), %xmm3 /* LCPI0_7(%rip) */ - QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90 - -LBB0_15: - LONG $0x6f79c1c4; BYTE $0x22 // vmovdqa (%r10), %xmm4 - LONG $0xe874d9c5 // vpcmpeqb %xmm0, %xmm4, %xmm5 - LONG $0xf174d9c5 // vpcmpeqb %xmm1, %xmm4, %xmm6 - LONG $0xeeebd1c5 // vpor %xmm6, %xmm5, %xmm5 - LONG $0xf274d9c5 // vpcmpeqb %xmm2, %xmm4, %xmm6 - LONG $0xe374d9c5 // vpcmpeqb %xmm3, %xmm4, %xmm4 - LONG $0xe6ebd9c5 // vpor %xmm6, %xmm4, %xmm4 - LONG $0xe5ebd9c5 // vpor %xmm5, %xmm4, %xmm4 - LONG $0xc4d7f9c5 // vpmovmskb %xmm4, %eax - LONG $0xfff88366 // cmpw $-1, %ax - LONG $0x006b850f; WORD $0x0000 // jne LBB0_16, $107(%rip) - LONG $0x10c28349 // addq $16, %r10 - LONG $0xf0c28348 // addq $-16, %rdx - LONG $0xf0c68348 // addq $-16, %rsi - LONG $0x0ffa8348 // cmpq $15, %rdx - LONG $0xffbb870f; WORD $0xffff // ja LBB0_15, $-69(%rip) + LONG $0x1ffe8348 // cmpq $31, %rsi + LONG $0xffd4870f; WORD $0xffff // ja LBB0_2, $-44(%rip) -LBB0_18: - WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx - LONG $0x0037840f; WORD $0x0000 // je LBB0_25, $55(%rip) - LONG $0x12048d4d // leaq (%r10,%rdx), %r8 - WORD $0xc031 // xorl %eax, %eax - QUAD $0x000100002600b949; WORD $0x0000 // movabsq $4294977024, %r9 +LBB0_5: + WORD $0x8548; BYTE $0xf6 // testq %rsi, %rsi + LONG $0x003a840f; WORD $0x0000 // je LBB0_12, $58(%rip) + LONG $0x30048d4c // leaq (%rax,%rsi), %r8 + WORD $0xff48; BYTE $0xc0 // incq %rax + QUAD $0x000100002600ba48; WORD $0x0000 // movabsq $4294977024, %rdx -LBB0_20: - LONG $0x34be0f41; BYTE $0x02 // movsbl (%r10,%rax), %esi - WORD $0xfe83; BYTE $0x20 // cmpl $32, %esi - LONG $0x0036870f; WORD $0x0000 // ja LBB0_22, $54(%rip) - LONG $0xf1a30f49 // btq %rsi, %r9 - LONG $0x002c830f; WORD $0x0000 // jae LBB0_22, $44(%rip) +LBB0_7: + LONG $0xff48be0f // movsbl $-1(%rax), %ecx + WORD $0xf983; BYTE $0x20 // cmpl $32, %ecx + LONG $0x0038870f; WORD $0x0000 // ja LBB0_9, $56(%rip) + LONG $0xcaa30f48 // btq %rcx, %rdx + LONG $0x002e830f; WORD $0x0000 // jae LBB0_9, $46(%rip) + WORD $0xff48; BYTE $0xce // decq %rsi WORD $0xff48; BYTE $0xc0 // incq %rax - WORD $0x3948; BYTE $0xc2 // cmpq %rax, %rdx - LONG $0xffdc850f; WORD $0xffff // jne LBB0_20, $-36(%rip) - WORD $0x894d; BYTE $0xc2 // movq %r8, %r10 - -LBB0_25: - WORD $0x2949; BYTE $0xfa // subq %rdi, %r10 - -LBB0_26: - WORD $0x894c; BYTE $0xd0 // movq %r10, %rax - -LBB0_27: - BYTE $0x5d // popq %rbp - BYTE $0xc3 // retq + WORD $0x8548; BYTE $0xf6 // testq %rsi, %rsi + LONG $0xffda850f; WORD $0xffff // jne LBB0_7, $-38(%rip) + WORD $0x894c; BYTE $0xc0 // movq %r8, %rax -LBB0_10: +LBB0_12: + WORD $0x2948; BYTE $0xf8 // subq %rdi, %rax + BYTE $0x5d // popq %rbp WORD $0xf8c5; BYTE $0x77 // vzeroupper + BYTE $0xc3 // retq -LBB0_11: - WORD $0xd0f7 // notl %eax - WORD $0xbc0f; BYTE $0xc0 // bsfl %eax, %eax - WORD $0x2948; BYTE $0xf0 // subq %rsi, %rax +LBB0_3: + WORD $0x2948; BYTE $0xf8 // subq %rdi, %rax + WORD $0xd1f7 // notl %ecx + WORD $0x6348; BYTE $0xc9 // movslq %ecx, %rcx + LONG $0xc9bc0f48 // bsfq %rcx, %rcx + WORD $0x0148; BYTE $0xc8 // addq %rcx, %rax BYTE $0x5d // popq %rbp + WORD $0xf8c5; BYTE $0x77 // vzeroupper BYTE $0xc3 // retq -LBB0_16: - WORD $0xb70f; BYTE $0xc0 // movzwl %ax, %eax - LONG $0xffffeee9; BYTE $0xff // jmp LBB0_11, $-18(%rip) - -LBB0_22: - WORD $0x2949; BYTE $0xfa // subq %rdi, %r10 - WORD $0x0149; BYTE $0xc2 // addq %rax, %r10 - LONG $0xffffdbe9; BYTE $0xff // jmp LBB0_26, $-37(%rip) - WORD $0x0000; BYTE $0x00 // .p2align 5, 0x00 +LBB0_9: + WORD $0xf748; BYTE $0xd7 // notq %rdi + WORD $0x0148; BYTE $0xf8 // addq %rdi, %rax + BYTE $0x5d // popq %rbp + WORD $0xf8c5; BYTE $0x77 // vzeroupper + BYTE $0xc3 // retq + QUAD $0x0000000000000000; WORD $0x0000 // .p2align 5, 0x00 LCPI1_0: QUAD $0x3030303030303030; QUAD $0x3030303030303030 // .space 16, '0000000000000000' QUAD $0x3030303030303030; QUAD $0x3030303030303030 // .space 16, '0000000000000000' - // .p2align 4, 0x00 -LCPI1_1: - QUAD $0x3030303030303030; QUAD $0x3030303030303030 // .space 16, '0000000000000000' - // .p2align 4, 0x90 _f64toa: BYTE $0x55 // pushq %rbp @@ -207,271 +131,264 @@ _f64toa: LONG $0x34e8c148 // shrq $52, %rax LONG $0x0007ff25; BYTE $0x00 // andl $2047, %eax LONG $0x0007ff3d; BYTE $0x00 // cmpl $2047, %eax - LONG $0x0c1e840f; WORD $0x0000 // je LBB1_1, $3102(%rip) - WORD $0x8948; BYTE $0xfe // movq %rdi, %rsi + LONG $0x0ade840f; WORD $0x0000 // je LBB1_1, $2782(%rip) + WORD $0x8949; BYTE $0xfe // movq %rdi, %r14 WORD $0x07c6; BYTE $0x2d // movb $45, (%rdi) - WORD $0x8949; BYTE $0xd5 // movq %rdx, %r13 - LONG $0x3fedc149 // shrq $63, %r13 - LONG $0x2f3c8d4e // leaq (%rdi,%r13), %r15 + WORD $0x8949; BYTE $0xd4 // movq %rdx, %r12 + LONG $0x3fecc149 // shrq $63, %r12 + LONG $0x273c8d4e // leaq (%rdi,%r12), %r15 QUAD $0x00000000550c8d48 // leaq (,%rdx,2), %rcx WORD $0x8548; BYTE $0xc9 // testq %rcx, %rcx - LONG $0x01f5840f; WORD $0x0000 // je LBB1_3, $501(%rip) + LONG $0x01e3840f; WORD $0x0000 // je LBB1_3, $483(%rip) QUAD $0xffffffffffffbf48; WORD $0x000f // movabsq $4503599627370495, %rdi WORD $0x2148; BYTE $0xfa // andq %rdi, %rdx WORD $0xc085 // testl %eax, %eax - LONG $0xd0758948 // movq %rsi, $-48(%rbp) - LONG $0x0bea840f; WORD $0x0000 // je LBB1_5, $3050(%rip) + LONG $0x0aae840f; WORD $0x0000 // je LBB1_5, $2734(%rip) WORD $0xff48; BYTE $0xc7 // incq %rdi WORD $0x0948; BYTE $0xd7 // orq %rdx, %rdi - LONG $0xfbcdb08d; WORD $0xffff // leal $-1075(%rax), %esi + LONG $0xfbcd988d; WORD $0xffff // leal $-1075(%rax), %ebx LONG $0xfc01888d; WORD $0xffff // leal $-1023(%rax), %ecx WORD $0xf983; BYTE $0x34 // cmpl $52, %ecx - LONG $0x001d870f; WORD $0x0000 // ja LBB1_6, $29(%rip) - LONG $0x000433b9; BYTE $0x00 // movl $1075, %ecx - WORD $0xc129 // subl %eax, %ecx - LONG $0xffc3c748; WORD $0xffff; BYTE $0xff // movq $-1, %rbx - WORD $0xd348; BYTE $0xe3 // shlq %cl, %rbx - WORD $0xf748; BYTE $0xd3 // notq %rbx - WORD $0x8548; BYTE $0xdf // testq %rbx, %rdi + LONG $0x001a870f; WORD $0x0000 // ja LBB1_6, $26(%rip) + WORD $0xd989 // movl %ebx, %ecx + WORD $0xd9f7 // negl %ecx + LONG $0xffc6c748; WORD $0xffff; BYTE $0xff // movq $-1, %rsi + WORD $0xd348; BYTE $0xe6 // shlq %cl, %rsi + WORD $0xf748; BYTE $0xd6 // notq %rsi + WORD $0x8548; BYTE $0xf7 // testq %rsi, %rdi LONG $0x0421840f; WORD $0x0000 // je LBB1_11, $1057(%rip) LBB1_6: WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx WORD $0x940f; BYTE $0xc1 // sete %cl - WORD $0xf883; BYTE $0x02 // cmpl $2, %eax - WORD $0x930f; BYTE $0xc0 // setae %al + WORD $0xf883; BYTE $0x01 // cmpl $1, %eax + WORD $0x970f; BYTE $0xc0 // seta %al WORD $0xc820 // andb %cl, %al - QUAD $0x00000000bd0c8d4c // leaq (,%rdi,4), %r9 WORD $0xb60f; BYTE $0xc0 // movzbl %al, %eax - LONG $0xb81c8d48 // leaq (%rax,%rdi,4), %rbx - LONG $0xfec38348 // addq $-2, %rbx - LONG $0x4413ce69; WORD $0x0013 // imull $1262611, %esi, %ecx - LONG $0x01918d44; WORD $0xf801; BYTE $0xff // leal $-524031(%rcx), %r10d + LONG $0x4413cb69; WORD $0x0013 // imull $1262611, %ebx, %ecx + WORD $0xd231 // xorl %edx, %edx WORD $0xc084 // testb %al, %al - LONG $0xd1440f44 // cmovel %ecx, %r10d - QUAD $0x00000002bd048d4c // leaq $2(,%rdi,4), %r8 - LONG $0x16fac141 // sarl $22, %r10d - LONG $0xb1ca6941; WORD $0xe56c; BYTE $0xff // imull $-1741647, %r10d, %ecx + LONG $0x0101b941; WORD $0xfff8 // movl $-524031, %r9d + LONG $0xca440f44 // cmovel %edx, %r9d + LONG $0xb8748d48; BYTE $0xfe // leaq $-2(%rax,%rdi,4), %rsi + WORD $0x0141; BYTE $0xc9 // addl %ecx, %r9d + LONG $0x16f9c141 // sarl $22, %r9d + LONG $0xb1c96941; WORD $0xe56c; BYTE $0xff // imull $-1741647, %r9d, %ecx WORD $0xe9c1; BYTE $0x13 // shrl $19, %ecx - WORD $0xf101 // addl %esi, %ecx + WORD $0xd901 // addl %ebx, %ecx LONG $0x000124b8; BYTE $0x00 // movl $292, %eax - WORD $0x2944; BYTE $0xd0 // subl %r10d, %eax + WORD $0x2944; BYTE $0xc8 // subl %r9d, %eax LONG $0x04e0c148 // shlq $4, %rax - LONG $0x44158d48; WORD $0x00cc; BYTE $0x00 // leaq $52292(%rip), %rdx /* _pow10_ceil_sig.g(%rip) */ + LONG $0xaa158d48; WORD $0x00c4; BYTE $0x00 // leaq $50346(%rip), %rdx /* _pow10_ceil_sig.g(%rip) */ LONG $0x101c8b4c // movq (%rax,%rdx), %r11 - LONG $0x10748b4c; BYTE $0x08 // movq $8(%rax,%rdx), %r14 + LONG $0x106c8b4c; BYTE $0x08 // movq $8(%rax,%rdx), %r13 WORD $0xc1fe // incb %cl - WORD $0xd348; BYTE $0xe3 // shlq %cl, %rbx - WORD $0x8948; BYTE $0xd8 // movq %rbx, %rax - WORD $0xf749; BYTE $0xe6 // mulq %r14 - WORD $0x8948; BYTE $0xd6 // movq %rdx, %rsi - WORD $0x8948; BYTE $0xd8 // movq %rbx, %rax - WORD $0xf749; BYTE $0xe3 // mulq %r11 - WORD $0x0148; BYTE $0xf0 // addq %rsi, %rax - LONG $0x00d28348 // adcq $0, %rdx - WORD $0xf631 // xorl %esi, %esi - LONG $0xfffea948; WORD $0xffff // testq $-2, %rax - LONG $0xc6950f40 // setne %sil - WORD $0x0948; BYTE $0xd6 // orq %rdx, %rsi - WORD $0xd349; BYTE $0xe1 // shlq %cl, %r9 - WORD $0x894c; BYTE $0xc8 // movq %r9, %rax - WORD $0xf749; BYTE $0xe6 // mulq %r14 + WORD $0xd348; BYTE $0xe6 // shlq %cl, %rsi + WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax + WORD $0xf749; BYTE $0xe5 // mulq %r13 WORD $0x8948; BYTE $0xd3 // movq %rdx, %rbx - WORD $0x894c; BYTE $0xc8 // movq %r9, %rax + WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax WORD $0xf749; BYTE $0xe3 // mulq %r11 - WORD $0x8949; BYTE $0xd1 // movq %rdx, %r9 + QUAD $0x00000000bd348d48 // leaq (,%rdi,4), %rsi WORD $0x0148; BYTE $0xd8 // addq %rbx, %rax - LONG $0x00d18349 // adcq $0, %r9 + LONG $0x00d28348 // adcq $0, %rdx WORD $0xdb31 // xorl %ebx, %ebx - LONG $0xfffea948; WORD $0xffff // testq $-2, %rax - WORD $0x950f; BYTE $0xc3 // setne %bl - WORD $0x094c; BYTE $0xcb // orq %r9, %rbx - WORD $0xd349; BYTE $0xe0 // shlq %cl, %r8 - WORD $0x894c; BYTE $0xc0 // movq %r8, %rax - WORD $0xf749; BYTE $0xe6 // mulq %r14 + LONG $0x01f88348 // cmpq $1, %rax + WORD $0x970f; BYTE $0xc3 // seta %bl + WORD $0x0948; BYTE $0xd3 // orq %rdx, %rbx + WORD $0xd348; BYTE $0xe6 // shlq %cl, %rsi + WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax + WORD $0xf749; BYTE $0xe5 // mulq %r13 + WORD $0x8949; BYTE $0xd2 // movq %rdx, %r10 + WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax + WORD $0xf749; BYTE $0xe3 // mulq %r11 + WORD $0x8949; BYTE $0xd0 // movq %rdx, %r8 + QUAD $0x00000002bd348d48 // leaq $2(,%rdi,4), %rsi + WORD $0x014c; BYTE $0xd0 // addq %r10, %rax + LONG $0x00d08349 // adcq $0, %r8 + WORD $0x3145; BYTE $0xd2 // xorl %r10d, %r10d + LONG $0x01f88348 // cmpq $1, %rax + LONG $0xc2970f41 // seta %r10b + WORD $0x094d; BYTE $0xc2 // orq %r8, %r10 + WORD $0xd348; BYTE $0xe6 // shlq %cl, %rsi + WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax + WORD $0xf749; BYTE $0xe5 // mulq %r13 WORD $0x8948; BYTE $0xd1 // movq %rdx, %rcx - WORD $0x894c; BYTE $0xc0 // movq %r8, %rax + WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax WORD $0xf749; BYTE $0xe3 // mulq %r11 WORD $0x0148; BYTE $0xc8 // addq %rcx, %rax LONG $0x00d28348 // adcq $0, %rdx WORD $0xc931 // xorl %ecx, %ecx - LONG $0xfffea948; WORD $0xffff // testq $-2, %rax - WORD $0x950f; BYTE $0xc1 // setne %cl + LONG $0x01f88348 // cmpq $1, %rax + WORD $0x970f; BYTE $0xc1 // seta %cl WORD $0x0948; BYTE $0xd1 // orq %rdx, %rcx WORD $0xe783; BYTE $0x01 // andl $1, %edi - WORD $0x0148; BYTE $0xfe // addq %rdi, %rsi + WORD $0x0148; BYTE $0xfb // addq %rdi, %rbx WORD $0x2948; BYTE $0xf9 // subq %rdi, %rcx - LONG $0x28fb8348 // cmpq $40, %rbx - LONG $0x0043820f; WORD $0x0000 // jb LBB1_28, $67(%rip) + LONG $0x28fa8349 // cmpq $40, %r10 + LONG $0x003e820f; WORD $0x0000 // jb LBB1_29, $62(%rip) QUAD $0xcccccccccccdba48; WORD $0xcccc // movabsq $-3689348814741910323, %rdx - WORD $0x894c; BYTE $0xc8 // movq %r9, %rax + WORD $0x894c; BYTE $0xc0 // movq %r8, %rax WORD $0xf748; BYTE $0xe2 // mulq %rdx WORD $0x8948; BYTE $0xd7 // movq %rdx, %rdi LONG $0x05efc148 // shrq $5, %rdi QUAD $0x00000000fd048d48 // leaq (,%rdi,8), %rax LONG $0x80148d48 // leaq (%rax,%rax,4), %rdx - WORD $0x3948; BYTE $0xd6 // cmpq %rdx, %rsi - LONG $0xc0970f41 // seta %r8b - LONG $0x80148d48 // leaq (%rax,%rax,4), %rdx - LONG $0x28c28348 // addq $40, %rdx - WORD $0xc031 // xorl %eax, %eax - WORD $0x3948; BYTE $0xca // cmpq %rcx, %rdx + WORD $0x3948; BYTE $0xd3 // cmpq %rdx, %rbx + LONG $0xc6970f40 // seta %sil + LONG $0x80448d48; BYTE $0x28 // leaq $40(%rax,%rax,4), %rax + WORD $0x3948; BYTE $0xc8 // cmpq %rcx, %rax WORD $0x960f; BYTE $0xc2 // setbe %dl - WORD $0x3841; BYTE $0xd0 // cmpb %dl, %r8b - LONG $0x0134840f; WORD $0x0000 // je LBB1_8, $308(%rip) + WORD $0x3040; BYTE $0xf2 // xorb %sil, %dl + LONG $0x0130840f; WORD $0x0000 // je LBB1_8, $304(%rip) -LBB1_28: - WORD $0x894d; BYTE $0xc8 // movq %r9, %r8 - LONG $0x02e8c149 // shrq $2, %r8 - WORD $0x894c; BYTE $0xca // movq %r9, %rdx +LBB1_29: + WORD $0x894c; BYTE $0xc0 // movq %r8, %rax + LONG $0x02e8c148 // shrq $2, %rax + WORD $0x894c; BYTE $0xc2 // movq %r8, %rdx LONG $0xfce28348 // andq $-4, %rdx - WORD $0x3948; BYTE $0xd6 // cmpq %rdx, %rsi + WORD $0x3948; BYTE $0xd3 // cmpq %rdx, %rbx LONG $0xc7970f40 // seta %dil LONG $0x04728d48 // leaq $4(%rdx), %rsi WORD $0x3948; BYTE $0xce // cmpq %rcx, %rsi - WORD $0x960f; BYTE $0xc0 // setbe %al - WORD $0x3040; BYTE $0xf8 // xorb %dil, %al - LONG $0x0055840f; WORD $0x0000 // je LBB1_29, $85(%rip) + WORD $0x960f; BYTE $0xc3 // setbe %bl + WORD $0x3040; BYTE $0xfb // xorb %dil, %bl + LONG $0x0053840f; WORD $0x0000 // je LBB1_30, $83(%rip) LONG $0x02ca8348 // orq $2, %rdx LONG $0x000001bf; BYTE $0x00 // movl $1, %edi - WORD $0x3948; BYTE $0xd3 // cmpq %rdx, %rbx - LONG $0x000e870f; WORD $0x0000 // ja LBB1_32, $14(%rip) - WORD $0x940f; BYTE $0xc0 // sete %al - LONG $0x02e9c041 // shrb $2, %r9b - WORD $0x2041; BYTE $0xc1 // andb %al, %r9b - LONG $0xf9b60f41 // movzbl %r9b, %edi - -LBB1_32: - WORD $0x014c; BYTE $0xc7 // addq %r8, %rdi - QUAD $0x0001ffffff80bc49; WORD $0x0000 // movabsq $8589934464, %r12 - QUAD $0x540be47f24848d49 // leaq $1410065535(%r12), %rax + WORD $0x3949; BYTE $0xd2 // cmpq %rdx, %r10 + LONG $0x000e870f; WORD $0x0000 // ja LBB1_33, $14(%rip) + WORD $0x940f; BYTE $0xc1 // sete %cl + LONG $0x02e8c041 // shrb $2, %r8b + WORD $0x2041; BYTE $0xc8 // andb %cl, %r8b + LONG $0xf8b60f41 // movzbl %r8b, %edi + +LBB1_33: + WORD $0x0148; BYTE $0xc7 // addq %rax, %rdi + QUAD $0x0001ffffff80b848; WORD $0x0000 // movabsq $8589934464, %rax + LONG $0xe47f0548; WORD $0x540b // addq $1410065535, %rax WORD $0x3948; BYTE $0xc7 // cmpq %rax, %rdi - LONG $0x003c870f; WORD $0x0000 // ja LBB1_34, $60(%rip) - LONG $0x0000ece9; BYTE $0x00 // jmp LBB1_40, $236(%rip) + LONG $0x003a870f; WORD $0x0000 // ja LBB1_35, $58(%rip) + LONG $0x0000eae9; BYTE $0x00 // jmp LBB1_41, $234(%rip) LBB1_3: LONG $0x3007c641 // movb $48, (%r15) - WORD $0x2941; BYTE $0xf7 // subl %esi, %r15d + WORD $0x2945; BYTE $0xf7 // subl %r14d, %r15d WORD $0xff41; BYTE $0xc7 // incl %r15d WORD $0x8944; BYTE $0xfb // movl %r15d, %ebx - LONG $0x0009e1e9; BYTE $0x00 // jmp LBB1_123, $2529(%rip) + LONG $0x0008a2e9; BYTE $0x00 // jmp LBB1_116, $2210(%rip) -LBB1_29: +LBB1_30: WORD $0x3948; BYTE $0xf1 // cmpq %rsi, %rcx - LONG $0xffd88349 // sbbq $-1, %r8 - WORD $0x894c; BYTE $0xc7 // movq %r8, %rdi - QUAD $0x0001ffffff80bc49; WORD $0x0000 // movabsq $8589934464, %r12 - QUAD $0x540be47f24848d49 // leaq $1410065535(%r12), %rax + LONG $0xffd88348 // sbbq $-1, %rax + WORD $0x8948; BYTE $0xc7 // movq %rax, %rdi + QUAD $0x0001ffffff80b848; WORD $0x0000 // movabsq $8589934464, %rax + LONG $0xe47f0548; WORD $0x540b // addq $1410065535, %rax WORD $0x3948; BYTE $0xc7 // cmpq %rax, %rdi - LONG $0x00b5860f; WORD $0x0000 // jbe LBB1_40, $181(%rip) + LONG $0x00b5860f; WORD $0x0000 // jbe LBB1_41, $181(%rip) -LBB1_34: +LBB1_35: WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax LONG $0x0be8c148 // shrq $11, %rax LONG $0x00000bba; BYTE $0x00 // movl $11, %edx LONG $0x0edd3d48; WORD $0x02e9 // cmpq $48828125, %rax - LONG $0x0136820f; WORD $0x0000 // jb LBB1_49, $310(%rip) + LONG $0x0127820f; WORD $0x0000 // jb LBB1_51, $295(%rip) WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax LONG $0x0ce8c148 // shrq $12, %rax LONG $0x00000cba; BYTE $0x00 // movl $12, %edx LONG $0x4a513d48; WORD $0x0e8d // cmpq $244140625, %rax - LONG $0x011e820f; WORD $0x0000 // jb LBB1_49, $286(%rip) + LONG $0x010f820f; WORD $0x0000 // jb LBB1_51, $271(%rip) WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax LONG $0x0de8c148 // shrq $13, %rax LONG $0x00000dba; BYTE $0x00 // movl $13, %edx LONG $0x73953d48; WORD $0x48c2 // cmpq $1220703125, %rax - LONG $0x0106820f; WORD $0x0000 // jb LBB1_49, $262(%rip) + LONG $0x00f7820f; WORD $0x0000 // jb LBB1_51, $247(%rip) LONG $0x00000eba; BYTE $0x00 // movl $14, %edx QUAD $0x5af3107a4000b848; WORD $0x0000 // movabsq $100000000000000, %rax WORD $0x3948; BYTE $0xc7 // cmpq %rax, %rdi - LONG $0x00ee820f; WORD $0x0000 // jb LBB1_49, $238(%rip) + LONG $0x00df820f; WORD $0x0000 // jb LBB1_51, $223(%rip) LONG $0x00000fba; BYTE $0x00 // movl $15, %edx QUAD $0x8d7ea4c68000b848; WORD $0x0003 // movabsq $1000000000000000, %rax WORD $0x3948; BYTE $0xc7 // cmpq %rax, %rdi - LONG $0x00d6820f; WORD $0x0000 // jb LBB1_49, $214(%rip) + LONG $0x00c7820f; WORD $0x0000 // jb LBB1_51, $199(%rip) QUAD $0x86f26fc10000b848; WORD $0x0023 // movabsq $10000000000000000, %rax - WORD $0xd231 // xorl %edx, %edx WORD $0x3948; BYTE $0xc7 // cmpq %rax, %rdi - WORD $0x920f; BYTE $0xc2 // setb %dl - WORD $0xf283; BYTE $0x11 // xorl $17, %edx - LONG $0x0000bce9; BYTE $0x00 // jmp LBB1_49, $188(%rip) + LONG $0x000011ba; BYTE $0x00 // movl $17, %edx + +LBB1_50: + WORD $0xda83; BYTE $0x00 // sbbl $0, %edx + LONG $0x0000ade9; BYTE $0x00 // jmp LBB1_51, $173(%rip) LBB1_8: - WORD $0xd088 // movb %dl, %al - WORD $0x0148; BYTE $0xc7 // addq %rax, %rdi - WORD $0xff41; BYTE $0xc2 // incl %r10d - QUAD $0x0001ffffff80bc49; WORD $0x0000 // movabsq $8589934464, %r12 - QUAD $0x540be47f24848d49 // leaq $1410065535(%r12), %rax + WORD $0x3948; BYTE $0xc1 // cmpq %rax, %rcx + LONG $0xffdf8348 // sbbq $-1, %rdi + WORD $0xff41; BYTE $0xc1 // incl %r9d + QUAD $0x0001ffffff80b848; WORD $0x0000 // movabsq $8589934464, %rax + LONG $0xe47f0548; WORD $0x540b // addq $1410065535, %rax WORD $0x3948; BYTE $0xc7 // cmpq %rax, %rdi - LONG $0xff4b870f; WORD $0xffff // ja LBB1_34, $-181(%rip) + LONG $0xff4b870f; WORD $0xffff // ja LBB1_35, $-181(%rip) -LBB1_40: +LBB1_41: LONG $0x000001ba; BYTE $0x00 // movl $1, %edx LONG $0x0aff8348 // cmpq $10, %rdi - LONG $0x008a820f; WORD $0x0000 // jb LBB1_49, $138(%rip) + LONG $0x007b820f; WORD $0x0000 // jb LBB1_51, $123(%rip) LONG $0x000002ba; BYTE $0x00 // movl $2, %edx LONG $0x64ff8348 // cmpq $100, %rdi - LONG $0x007b820f; WORD $0x0000 // jb LBB1_49, $123(%rip) + LONG $0x006c820f; WORD $0x0000 // jb LBB1_51, $108(%rip) LONG $0x000003ba; BYTE $0x00 // movl $3, %edx LONG $0xe8ff8148; WORD $0x0003; BYTE $0x00 // cmpq $1000, %rdi - LONG $0x0069820f; WORD $0x0000 // jb LBB1_49, $105(%rip) + LONG $0x005a820f; WORD $0x0000 // jb LBB1_51, $90(%rip) LONG $0x000004ba; BYTE $0x00 // movl $4, %edx LONG $0x10ff8148; WORD $0x0027; BYTE $0x00 // cmpq $10000, %rdi - LONG $0x0057820f; WORD $0x0000 // jb LBB1_49, $87(%rip) + LONG $0x0048820f; WORD $0x0000 // jb LBB1_51, $72(%rip) LONG $0x000005ba; BYTE $0x00 // movl $5, %edx LONG $0xa0ff8148; WORD $0x0186; BYTE $0x00 // cmpq $100000, %rdi - LONG $0x0045820f; WORD $0x0000 // jb LBB1_49, $69(%rip) + LONG $0x0036820f; WORD $0x0000 // jb LBB1_51, $54(%rip) LONG $0x000006ba; BYTE $0x00 // movl $6, %edx LONG $0x40ff8148; WORD $0x0f42; BYTE $0x00 // cmpq $1000000, %rdi - LONG $0x0033820f; WORD $0x0000 // jb LBB1_49, $51(%rip) + LONG $0x0024820f; WORD $0x0000 // jb LBB1_51, $36(%rip) LONG $0x000007ba; BYTE $0x00 // movl $7, %edx LONG $0x80ff8148; WORD $0x9896; BYTE $0x00 // cmpq $10000000, %rdi - LONG $0x0021820f; WORD $0x0000 // jb LBB1_49, $33(%rip) + LONG $0x0012820f; WORD $0x0000 // jb LBB1_51, $18(%rip) LONG $0x000008ba; BYTE $0x00 // movl $8, %edx LONG $0x00ff8148; WORD $0xf5e1; BYTE $0x05 // cmpq $100000000, %rdi - LONG $0x000f820f; WORD $0x0000 // jb LBB1_49, $15(%rip) - LONG $0x00ff8148; WORD $0x9aca; BYTE $0x3b // cmpq $1000000000, %rdi - LONG $0x00000aba; BYTE $0x00 // movl $10, %edx - WORD $0xda83; BYTE $0x00 // sbbl $0, %edx - -LBB1_49: - LONG $0x12348d46 // leal (%rdx,%r10), %r14d - LONG $0x12048d42 // leal (%rdx,%r10), %eax - WORD $0xc083; BYTE $0xea // addl $-22, %eax - WORD $0xf883; BYTE $0xe4 // cmpl $-28, %eax - LONG $0x00a4870f; WORD $0x0000 // ja LBB1_62, $164(%rip) - LONG $0x01678d4d // leaq $1(%r15), %r12 - WORD $0x894c; BYTE $0xe6 // movq %r12, %rsi - LONG $0x0090eae8; BYTE $0x00 // callq _format_significand, $37098(%rip) - WORD $0x8948; BYTE $0xc3 // movq %rax, %rbx - LONG $0xd0558b4c // movq $-48(%rbp), %r10 - WORD $0x294c; BYTE $0xd0 // subq %r10, %rax - WORD $0x294c; BYTE $0xe8 // subq %r13, %rax - QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 + LONG $0x0754830f; WORD $0x0000 // jae LBB1_49, $1876(%rip) LBB1_51: - WORD $0xff48; BYTE $0xc8 // decq %rax + LONG $0x0a2c8d46 // leal (%rdx,%r9), %r13d + LONG $0x0a448d42; BYTE $0x05 // leal $5(%rdx,%r9), %eax + WORD $0xf883; BYTE $0x1b // cmpl $27, %eax + LONG $0x009d820f; WORD $0x0000 // jb LBB1_64, $157(%rip) + LONG $0x01678d4d // leaq $1(%r15), %r12 + WORD $0x894c; BYTE $0xe6 // movq %r12, %rsi + LONG $0x008cafe8; BYTE $0x00 // callq _format_significand, $36015(%rip) + WORD $0x8948; BYTE $0xc3 // movq %rax, %rbx + QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90 + +LBB1_53: LONG $0x30ff7b80 // cmpb $48, $-1(%rbx) LONG $0xff5b8d48 // leaq $-1(%rbx), %rbx - LONG $0xffef840f; WORD $0xffff // je LBB1_51, $-17(%rip) - LONG $0x4fb60f41; BYTE $0x01 // movzbl $1(%r15), %ecx - WORD $0x8841; BYTE $0x0f // movb %cl, (%r15) - LONG $0x02f88348 // cmpq $2, %rax - LONG $0x00088c0f; WORD $0x0000 // jl LBB1_54, $8(%rip) - WORD $0xff48; BYTE $0xc3 // incq %rbx + LONG $0xfff2840f; WORD $0xffff // je LBB1_53, $-14(%rip) + LONG $0x01478a41 // movb $1(%r15), %al + WORD $0x8841; BYTE $0x07 // movb %al, (%r15) + LONG $0x01438d48 // leaq $1(%rbx), %rax + WORD $0x8948; BYTE $0xc1 // movq %rax, %rcx + WORD $0x294c; BYTE $0xe1 // subq %r12, %rcx + LONG $0x02f98348 // cmpq $2, %rcx + LONG $0x00088c0f; WORD $0x0000 // jl LBB1_56, $8(%rip) LONG $0x2404c641; BYTE $0x2e // movb $46, (%r12) + WORD $0x8948; BYTE $0xc3 // movq %rax, %rbx -LBB1_54: +LBB1_56: WORD $0x03c6; BYTE $0x65 // movb $101, (%rbx) - WORD $0x8545; BYTE $0xf6 // testl %r14d, %r14d - LONG $0x011d8e0f; WORD $0x0000 // jle LBB1_55, $285(%rip) - WORD $0xff41; BYTE $0xce // decl %r14d + LONG $0xff458d41 // leal $-1(%r13), %eax + WORD $0x8545; BYTE $0xed // testl %r13d, %r13d + LONG $0x01548e0f; WORD $0x0000 // jle LBB1_57, $340(%rip) LONG $0x2b0143c6 // movb $43, $1(%rbx) - WORD $0x8944; BYTE $0xf0 // movl %r14d, %eax WORD $0xf883; BYTE $0x64 // cmpl $100, %eax - LONG $0x011f820f; WORD $0x0000 // jb LBB1_59, $287(%rip) + LONG $0x01568c0f; WORD $0x0000 // jl LBB1_61, $342(%rip) -LBB1_58: +LBB1_60: WORD $0xc189 // movl %eax, %ecx LONG $0xcccccdba; BYTE $0xcc // movl $3435973837, %edx LONG $0xd1af0f48 // imulq %rcx, %rdx @@ -479,100 +396,111 @@ LBB1_58: WORD $0x0c8d; BYTE $0x12 // leal (%rdx,%rdx), %ecx WORD $0x0c8d; BYTE $0x89 // leal (%rcx,%rcx,4), %ecx WORD $0xc829 // subl %ecx, %eax - LONG $0x080d8d48; WORD $0x00c8; BYTE $0x00 // leaq $51208(%rip), %rcx /* _Digits(%rip) */ + LONG $0x840d8d48; WORD $0x00c0; BYTE $0x00 // leaq $49284(%rip), %rcx /* _Digits(%rip) */ LONG $0x510cb70f // movzwl (%rcx,%rdx,2), %ecx LONG $0x024b8966 // movw %cx, $2(%rbx) WORD $0x300c // orb $48, %al WORD $0x4388; BYTE $0x04 // movb %al, $4(%rbx) LONG $0x05c38348 // addq $5, %rbx - LONG $0x0007b3e9; BYTE $0x00 // jmp LBB1_122, $1971(%rip) - -LBB1_62: - WORD $0x8545; BYTE $0xd2 // testl %r10d, %r10d - LONG $0x0105880f; WORD $0x0000 // js LBB1_63, $261(%rip) - WORD $0x8945; BYTE $0xf6 // movl %r14d, %r14d - LONG $0x371c8d4b // leaq (%r15,%r14), %rbx - WORD $0x894c; BYTE $0xfe // movq %r15, %rsi - LONG $0x0007dae8; BYTE $0x00 // callq _format_integer, $2010(%rip) - WORD $0x3948; BYTE $0xd8 // cmpq %rbx, %rax - LONG $0x0154830f; WORD $0x0000 // jae LBB1_103, $340(%rip) - LONG $0xd0558b4c // movq $-48(%rbp), %r10 - WORD $0x014d; BYTE $0xd5 // addq %r10, %r13 - WORD $0x014d; BYTE $0xf5 // addq %r14, %r13 - WORD $0x2949; BYTE $0xc5 // subq %rax, %r13 - LONG $0x10fd8349 // cmpq $16, %r13 - LONG $0x01f1830f; WORD $0x0000 // jae LBB1_105, $497(%rip) - -LBB1_120: - WORD $0x8948; BYTE $0xc2 // movq %rax, %rdx - LONG $0x000372e9; BYTE $0x00 // jmp LBB1_121, $882(%rip) + LONG $0x00068ee9; BYTE $0x00 // jmp LBB1_115, $1678(%rip) + +LBB1_64: + WORD $0x8545; BYTE $0xc9 // testl %r9d, %r9d + LONG $0x013c880f; WORD $0x0000 // js LBB1_65, $316(%rip) + WORD $0x634d; BYTE $0xed // movslq %r13d, %r13 + LONG $0x2f1c8d4b // leaq (%r15,%r13), %rbx + WORD $0x894c; BYTE $0xfe // movq %r15, %rsi + LONG $0x0006c6e8; BYTE $0x00 // callq _format_integer, $1734(%rip) + WORD $0x3948; BYTE $0xd8 // cmpq %rbx, %rax + LONG $0x066d830f; WORD $0x0000 // jae LBB1_115, $1645(%rip) + WORD $0x014d; BYTE $0xec // addq %r13, %r12 + WORD $0x2949; BYTE $0xc4 // subq %rax, %r12 + WORD $0x014d; BYTE $0xf4 // addq %r14, %r12 + LONG $0x80fc8149; WORD $0x0000; BYTE $0x00 // cmpq $128, %r12 + LONG $0x0317820f; WORD $0x0000 // jb LBB1_114, $791(%rip) + WORD $0x894c; BYTE $0xe1 // movq %r12, %rcx + LONG $0x80e18348 // andq $-128, %rcx + LONG $0x80798d48 // leaq $-128(%rcx), %rdi + WORD $0x8948; BYTE $0xfe // movq %rdi, %rsi + LONG $0x07eec148 // shrq $7, %rsi + WORD $0xff48; BYTE $0xc6 // incq %rsi + WORD $0xf289 // movl %esi, %edx + WORD $0xe283; BYTE $0x03 // andl $3, %edx + LONG $0x80ff8148; WORD $0x0001; BYTE $0x00 // cmpq $384, %rdi + LONG $0x01fc830f; WORD $0x0000 // jae LBB1_107, $508(%rip) + WORD $0xff31 // xorl %edi, %edi + LONG $0x00029de9; BYTE $0x00 // jmp LBB1_109, $669(%rip) LBB1_11: WORD $0xd348; BYTE $0xef // shrq %cl, %rdi QUAD $0x0001ffffff80b848; WORD $0x0000 // movabsq $8589934464, %rax LONG $0xe47f0548; WORD $0x540b // addq $1410065535, %rax WORD $0x3948; BYTE $0xc7 // cmpq %rax, %rdi - LONG $0x0130860f; WORD $0x0000 // jbe LBB1_17, $304(%rip) + LONG $0x013f860f; WORD $0x0000 // jbe LBB1_18, $319(%rip) WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax LONG $0x0be8c148 // shrq $11, %rax LONG $0x00000bba; BYTE $0x00 // movl $11, %edx LONG $0x0edd3d48; WORD $0x02e9 // cmpq $48828125, %rax - LONG $0x01a2820f; WORD $0x0000 // jb LBB1_27, $418(%rip) + LONG $0x01b1820f; WORD $0x0000 // jb LBB1_28, $433(%rip) WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax LONG $0x0ce8c148 // shrq $12, %rax LONG $0x00000cba; BYTE $0x00 // movl $12, %edx LONG $0x4a513d48; WORD $0x0e8d // cmpq $244140625, %rax - LONG $0x018a820f; WORD $0x0000 // jb LBB1_27, $394(%rip) + LONG $0x0199820f; WORD $0x0000 // jb LBB1_28, $409(%rip) WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax LONG $0x0de8c148 // shrq $13, %rax LONG $0x00000dba; BYTE $0x00 // movl $13, %edx LONG $0x73953d48; WORD $0x48c2 // cmpq $1220703125, %rax - LONG $0x0172820f; WORD $0x0000 // jb LBB1_27, $370(%rip) + LONG $0x0181820f; WORD $0x0000 // jb LBB1_28, $385(%rip) LONG $0x00000eba; BYTE $0x00 // movl $14, %edx QUAD $0x5af3107a4000b848; WORD $0x0000 // movabsq $100000000000000, %rax WORD $0x3948; BYTE $0xc7 // cmpq %rax, %rdi - LONG $0x015a820f; WORD $0x0000 // jb LBB1_27, $346(%rip) + LONG $0x0169820f; WORD $0x0000 // jb LBB1_28, $361(%rip) + LONG $0x00000fba; BYTE $0x00 // movl $15, %edx QUAD $0x8d7ea4c68000b848; WORD $0x0003 // movabsq $1000000000000000, %rax WORD $0x3948; BYTE $0xc7 // cmpq %rax, %rdi - LONG $0x000010ba; BYTE $0x00 // movl $16, %edx + LONG $0x0151820f; WORD $0x0000 // jb LBB1_28, $337(%rip) + QUAD $0x86f26fc10000b848; WORD $0x0023 // movabsq $10000000000000000, %rax + WORD $0x3948; BYTE $0xc7 // cmpq %rax, %rdi + LONG $0x000011ba; BYTE $0x00 // movl $17, %edx -LBB1_26: +LBB1_27: WORD $0xda83; BYTE $0x00 // sbbl $0, %edx - LONG $0x000140e9; BYTE $0x00 // jmp LBB1_27, $320(%rip) + LONG $0x000137e9; BYTE $0x00 // jmp LBB1_28, $311(%rip) -LBB1_55: +LBB1_57: LONG $0x2d0143c6 // movb $45, $1(%rbx) - LONG $0x000001b8; BYTE $0x00 // movl $1, %eax - WORD $0x2944; BYTE $0xf0 // subl %r14d, %eax + WORD $0xd8f7 // negl %eax WORD $0xf883; BYTE $0x64 // cmpl $100, %eax - LONG $0xfee1830f; WORD $0xffff // jae LBB1_58, $-287(%rip) + LONG $0xfeaa8d0f; WORD $0xffff // jge LBB1_60, $-342(%rip) -LBB1_59: +LBB1_61: WORD $0xf883; BYTE $0x0a // cmpl $10, %eax - LONG $0x008a820f; WORD $0x0000 // jb LBB1_61, $138(%rip) + LONG $0x00878c0f; WORD $0x0000 // jl LBB1_63, $135(%rip) WORD $0xc089 // movl %eax, %eax - LONG $0xf50d8d48; WORD $0x00c6; BYTE $0x00 // leaq $50933(%rip), %rcx /* _Digits(%rip) */ + LONG $0x3a0d8d48; WORD $0x00bf; BYTE $0x00 // leaq $48954(%rip), %rcx /* _Digits(%rip) */ LONG $0x4104b70f // movzwl (%rcx,%rax,2), %eax LONG $0x02438966 // movw %ax, $2(%rbx) LONG $0x04c38348 // addq $4, %rbx - LONG $0x0006a5e9; BYTE $0x00 // jmp LBB1_122, $1701(%rip) + LONG $0x000549e9; BYTE $0x00 // jmp LBB1_115, $1353(%rip) -LBB1_63: - WORD $0x8545; BYTE $0xf6 // testl %r14d, %r14d - LONG $0x03ca8f0f; WORD $0x0000 // jg LBB1_76, $970(%rip) +LBB1_65: + WORD $0x8545; BYTE $0xed // testl %r13d, %r13d + LONG $0x031f8f0f; WORD $0x0000 // jg LBB1_78, $799(%rip) LONG $0x07c74166; WORD $0x2e30 // movw $11824, (%r15) LONG $0x02c78349 // addq $2, %r15 - WORD $0x8545; BYTE $0xf6 // testl %r14d, %r14d - LONG $0x03b7890f; WORD $0x0000 // jns LBB1_76, $951(%rip) + WORD $0x8545; BYTE $0xed // testl %r13d, %r13d + LONG $0x030c890f; WORD $0x0000 // jns LBB1_78, $780(%rip) WORD $0x8941; BYTE $0xd0 // movl %edx, %r8d WORD $0xf741; BYTE $0xd0 // notl %r8d - WORD $0x2945; BYTE $0xd0 // subl %r10d, %r8d + WORD $0x2945; BYTE $0xc8 // subl %r9d, %r8d WORD $0xc031 // xorl %eax, %eax LONG $0x7ff88341 // cmpl $127, %r8d - LONG $0x038e820f; WORD $0x0000 // jb LBB1_74, $910(%rip) + LONG $0x02de820f; WORD $0x0000 // jb LBB1_76, $734(%rip) WORD $0xff49; BYTE $0xc0 // incq %r8 WORD $0x894c; BYTE $0xc0 // movq %r8, %rax - WORD $0x214c; BYTE $0xe0 // andq %r12, %rax + QUAD $0x0001ffffff80b948; WORD $0x0000 // movabsq $8589934464, %rcx + WORD $0x2148; BYTE $0xc8 // andq %rcx, %rax LONG $0x80488d48 // leaq $-128(%rax), %rcx WORD $0x8948; BYTE $0xce // movq %rcx, %rsi LONG $0x07eec148 // shrq $7, %rsi @@ -580,81 +508,56 @@ LBB1_63: WORD $0x8941; BYTE $0xf1 // movl %esi, %r9d LONG $0x03e18341 // andl $3, %r9d LONG $0x80f98148; WORD $0x0001; BYTE $0x00 // cmpq $384, %rcx - LONG $0x0264830f; WORD $0x0000 // jae LBB1_68, $612(%rip) + LONG $0x01b7830f; WORD $0x0000 // jae LBB1_70, $439(%rip) WORD $0xc931 // xorl %ecx, %ecx - LONG $0xd0558b4c // movq $-48(%rbp), %r10 - LONG $0x000307e9; BYTE $0x00 // jmp LBB1_70, $775(%rip) + LONG $0x00025ae9; BYTE $0x00 // jmp LBB1_72, $602(%rip) -LBB1_103: - LONG $0xd0558b4c // movq $-48(%rbp), %r10 - LONG $0x000635e9; BYTE $0x00 // jmp LBB1_122, $1589(%rip) - -LBB1_61: +LBB1_63: WORD $0x3004 // addb $48, %al WORD $0x4388; BYTE $0x02 // movb %al, $2(%rbx) LONG $0x03c38348 // addq $3, %rbx - LONG $0x000627e9; BYTE $0x00 // jmp LBB1_122, $1575(%rip) + LONG $0x0004cee9; BYTE $0x00 // jmp LBB1_115, $1230(%rip) -LBB1_17: +LBB1_18: LONG $0x000001ba; BYTE $0x00 // movl $1, %edx LONG $0x0aff8348 // cmpq $10, %rdi - LONG $0x007b820f; WORD $0x0000 // jb LBB1_27, $123(%rip) + LONG $0x007b820f; WORD $0x0000 // jb LBB1_28, $123(%rip) LONG $0x000002ba; BYTE $0x00 // movl $2, %edx LONG $0x64ff8348 // cmpq $100, %rdi - LONG $0x006c820f; WORD $0x0000 // jb LBB1_27, $108(%rip) + LONG $0x006c820f; WORD $0x0000 // jb LBB1_28, $108(%rip) LONG $0x000003ba; BYTE $0x00 // movl $3, %edx LONG $0xe8ff8148; WORD $0x0003; BYTE $0x00 // cmpq $1000, %rdi - LONG $0x005a820f; WORD $0x0000 // jb LBB1_27, $90(%rip) + LONG $0x005a820f; WORD $0x0000 // jb LBB1_28, $90(%rip) LONG $0x000004ba; BYTE $0x00 // movl $4, %edx LONG $0x10ff8148; WORD $0x0027; BYTE $0x00 // cmpq $10000, %rdi - LONG $0x0048820f; WORD $0x0000 // jb LBB1_27, $72(%rip) + LONG $0x0048820f; WORD $0x0000 // jb LBB1_28, $72(%rip) LONG $0x000005ba; BYTE $0x00 // movl $5, %edx LONG $0xa0ff8148; WORD $0x0186; BYTE $0x00 // cmpq $100000, %rdi - LONG $0x0036820f; WORD $0x0000 // jb LBB1_27, $54(%rip) + LONG $0x0036820f; WORD $0x0000 // jb LBB1_28, $54(%rip) LONG $0x000006ba; BYTE $0x00 // movl $6, %edx LONG $0x40ff8148; WORD $0x0f42; BYTE $0x00 // cmpq $1000000, %rdi - LONG $0x0024820f; WORD $0x0000 // jb LBB1_27, $36(%rip) + LONG $0x0024820f; WORD $0x0000 // jb LBB1_28, $36(%rip) LONG $0x000007ba; BYTE $0x00 // movl $7, %edx LONG $0x80ff8148; WORD $0x9896; BYTE $0x00 // cmpq $10000000, %rdi - LONG $0x0012820f; WORD $0x0000 // jb LBB1_27, $18(%rip) + LONG $0x0012820f; WORD $0x0000 // jb LBB1_28, $18(%rip) LONG $0x000008ba; BYTE $0x00 // movl $8, %edx LONG $0x00ff8148; WORD $0xf5e1; BYTE $0x05 // cmpq $100000000, %rdi - LONG $0x05c8830f; WORD $0x0000 // jae LBB1_25, $1480(%rip) + LONG $0x0480830f; WORD $0x0000 // jae LBB1_26, $1152(%rip) -LBB1_27: +LBB1_28: WORD $0x894c; BYTE $0xfe // movq %r15, %rsi - LONG $0x0005d4e8; BYTE $0x00 // callq _format_integer, $1492(%rip) + LONG $0x00048ce8; BYTE $0x00 // callq _format_integer, $1164(%rip) WORD $0x8948; BYTE $0xc3 // movq %rax, %rbx - WORD $0x5d2b; BYTE $0xd0 // subl $-48(%rbp), %ebx - LONG $0x00058de9; BYTE $0x00 // jmp LBB1_123, $1421(%rip) + LONG $0x000434e9; BYTE $0x00 // jmp LBB1_115, $1076(%rip) -LBB1_105: - LONG $0x80fd8149; WORD $0x0000; BYTE $0x00 // cmpq $128, %r13 - LONG $0x0007830f; WORD $0x0000 // jae LBB1_110, $7(%rip) - WORD $0xc931 // xorl %ecx, %ecx - LONG $0x00013ce9; BYTE $0x00 // jmp LBB1_107, $316(%rip) - -LBB1_110: - WORD $0x894c; BYTE $0xe9 // movq %r13, %rcx - LONG $0x80e18348 // andq $-128, %rcx - LONG $0x80798d48 // leaq $-128(%rcx), %rdi - WORD $0x8948; BYTE $0xfe // movq %rdi, %rsi - LONG $0x07eec148 // shrq $7, %rsi - WORD $0xff48; BYTE $0xc6 // incq %rsi - WORD $0xf289 // movl %esi, %edx - WORD $0xe283; BYTE $0x03 // andl $3, %edx - LONG $0x80ff8148; WORD $0x0001; BYTE $0x00 // cmpq $384, %rdi - LONG $0x0007830f; WORD $0x0000 // jae LBB1_112, $7(%rip) - WORD $0xff31 // xorl %edi, %edi - LONG $0x0000abe9; BYTE $0x00 // jmp LBB1_114, $171(%rip) - -LBB1_112: - LONG $0xfce68348 // andq $-4, %rsi - WORD $0xff31 // xorl %edi, %edi - QUAD $0xfffff8d9056ffdc5 // vmovdqa $-1831(%rip), %ymm0 /* LCPI1_0(%rip) */ - QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90 +LBB1_107: + LONG $0xfce68348 // andq $-4, %rsi + WORD $0xf748; BYTE $0xde // negq %rsi + WORD $0xff31 // xorl %edi, %edi + QUAD $0xfffff923056ffdc5 // vmovdqa $-1757(%rip), %ymm0 /* LCPI1_0(%rip) */ + WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 -LBB1_113: +LBB1_108: LONG $0x047ffec5; BYTE $0x38 // vmovdqu %ymm0, (%rax,%rdi) LONG $0x447ffec5; WORD $0x2038 // vmovdqu %ymm0, $32(%rax,%rdi) LONG $0x447ffec5; WORD $0x4038 // vmovdqu %ymm0, $64(%rax,%rdi) @@ -672,71 +575,47 @@ LBB1_113: QUAD $0x0001c038847ffec5; BYTE $0x00 // vmovdqu %ymm0, $448(%rax,%rdi) QUAD $0x0001e038847ffec5; BYTE $0x00 // vmovdqu %ymm0, $480(%rax,%rdi) LONG $0x00c78148; WORD $0x0002; BYTE $0x00 // addq $512, %rdi - LONG $0xfcc68348 // addq $-4, %rsi - LONG $0xff6c850f; WORD $0xffff // jne LBB1_113, $-148(%rip) + LONG $0x04c68348 // addq $4, %rsi + LONG $0xff6c850f; WORD $0xffff // jne LBB1_108, $-148(%rip) -LBB1_114: - WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx - LONG $0x0047840f; WORD $0x0000 // je LBB1_117, $71(%rip) - LONG $0x07348d48 // leaq (%rdi,%rax), %rsi - LONG $0x60c68348 // addq $96, %rsi - LONG $0x07e2c148 // shlq $7, %rdx - WORD $0xff31 // xorl %edi, %edi - QUAD $0xfffff81d056ffdc5 // vmovdqa $-2019(%rip), %ymm0 /* LCPI1_0(%rip) */ - QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 +LBB1_109: + WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx + LONG $0x0033840f; WORD $0x0000 // je LBB1_112, $51(%rip) + LONG $0x07748d48; BYTE $0x60 // leaq $96(%rdi,%rax), %rsi + WORD $0xf748; BYTE $0xda // negq %rdx + QUAD $0xfffff873056ffdc5 // vmovdqa $-1933(%rip), %ymm0 /* LCPI1_0(%rip) */ + WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 -LBB1_116: - LONG $0x447ffec5; WORD $0xa03e // vmovdqu %ymm0, $-96(%rsi,%rdi) - LONG $0x447ffec5; WORD $0xc03e // vmovdqu %ymm0, $-64(%rsi,%rdi) - LONG $0x447ffec5; WORD $0xe03e // vmovdqu %ymm0, $-32(%rsi,%rdi) - LONG $0x047ffec5; BYTE $0x3e // vmovdqu %ymm0, (%rsi,%rdi) - LONG $0x80ef8348 // subq $-128, %rdi - WORD $0x3948; BYTE $0xfa // cmpq %rdi, %rdx - LONG $0xffdc850f; WORD $0xffff // jne LBB1_116, $-36(%rip) - -LBB1_117: - WORD $0x3949; BYTE $0xcd // cmpq %rcx, %r13 - LONG $0x0444840f; WORD $0x0000 // je LBB1_122, $1092(%rip) - LONG $0x70c5f641 // testb $112, %r13b - LONG $0x004d840f; WORD $0x0000 // je LBB1_119, $77(%rip) +LBB1_111: + LONG $0x467ffec5; BYTE $0xa0 // vmovdqu %ymm0, $-96(%rsi) + LONG $0x467ffec5; BYTE $0xc0 // vmovdqu %ymm0, $-64(%rsi) + LONG $0x467ffec5; BYTE $0xe0 // vmovdqu %ymm0, $-32(%rsi) + LONG $0x067ffec5 // vmovdqu %ymm0, (%rsi) + LONG $0x80ee8348 // subq $-128, %rsi + WORD $0xff48; BYTE $0xc2 // incq %rdx + LONG $0xffe0850f; WORD $0xffff // jne LBB1_111, $-32(%rip) -LBB1_107: - WORD $0x894c; BYTE $0xee // movq %r13, %rsi - LONG $0xf0e68348 // andq $-16, %rsi - WORD $0x8948; BYTE $0xc2 // movq %rax, %rdx - WORD $0x0148; BYTE $0xf2 // addq %rsi, %rdx - QUAD $0xfffff7e4056ff9c5 // vmovdqa $-2076(%rip), %xmm0 /* LCPI1_1(%rip) */ - LONG $0x90909090 // .p2align 4, 0x90 +LBB1_112: + WORD $0x394c; BYTE $0xe1 // cmpq %r12, %rcx + LONG $0x0347840f; WORD $0x0000 // je LBB1_115, $839(%rip) + WORD $0x0148; BYTE $0xc8 // addq %rcx, %rax + LONG $0x90909090 // .p2align 4, 0x90 -LBB1_108: - LONG $0x047ffac5; BYTE $0x08 // vmovdqu %xmm0, (%rax,%rcx) - LONG $0x10c18348 // addq $16, %rcx - WORD $0x3948; BYTE $0xce // cmpq %rcx, %rsi - LONG $0xffee850f; WORD $0xffff // jne LBB1_108, $-18(%rip) - WORD $0x3949; BYTE $0xf5 // cmpq %rsi, %r13 - LONG $0x0406840f; WORD $0x0000 // je LBB1_122, $1030(%rip) - LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 +LBB1_114: + WORD $0x00c6; BYTE $0x30 // movb $48, (%rax) + WORD $0xff48; BYTE $0xc0 // incq %rax + WORD $0x3948; BYTE $0xc3 // cmpq %rax, %rbx + LONG $0xfff1850f; WORD $0xffff // jne LBB1_114, $-15(%rip) + LONG $0x00032ce9; BYTE $0x00 // jmp LBB1_115, $812(%rip) -LBB1_121: - WORD $0x02c6; BYTE $0x30 // movb $48, (%rdx) - WORD $0xff48; BYTE $0xc2 // incq %rdx - WORD $0x3948; BYTE $0xda // cmpq %rbx, %rdx - LONG $0xfff1820f; WORD $0xffff // jb LBB1_121, $-15(%rip) - LONG $0x0003ede9; BYTE $0x00 // jmp LBB1_122, $1005(%rip) - -LBB1_119: - WORD $0x0148; BYTE $0xc8 // addq %rcx, %rax - LONG $0xfffc6ae9; BYTE $0xff // jmp LBB1_120, $-918(%rip) - -LBB1_68: - LONG $0xfce68348 // andq $-4, %rsi - LONG $0xd0558b4c // movq $-48(%rbp), %r10 - LONG $0x2a1c8d4b // leaq (%r10,%r13), %rbx - LONG $0xe2c38148; WORD $0x0001; BYTE $0x00 // addq $482, %rbx - WORD $0xc931 // xorl %ecx, %ecx - QUAD $0xfffff767056ffdc5 // vmovdqa $-2201(%rip), %ymm0 /* LCPI1_0(%rip) */ +LBB1_70: + QUAD $0x000001e2349c8d4b // leaq $482(%r12,%r14), %rbx + LONG $0xfce68348 // andq $-4, %rsi + WORD $0xf748; BYTE $0xde // negq %rsi + WORD $0xc931 // xorl %ecx, %ecx + QUAD $0xfffff813056ffdc5 // vmovdqa $-2029(%rip), %ymm0 /* LCPI1_0(%rip) */ -LBB1_69: +LBB1_71: QUAD $0xfffe200b847ffec5; BYTE $0xff // vmovdqu %ymm0, $-480(%rbx,%rcx) QUAD $0xfffe400b847ffec5; BYTE $0xff // vmovdqu %ymm0, $-448(%rbx,%rcx) QUAD $0xfffe600b847ffec5; BYTE $0xff // vmovdqu %ymm0, $-416(%rbx,%rcx) @@ -754,241 +633,192 @@ LBB1_69: LONG $0x447ffec5; WORD $0xe00b // vmovdqu %ymm0, $-32(%rbx,%rcx) LONG $0x047ffec5; BYTE $0x0b // vmovdqu %ymm0, (%rbx,%rcx) LONG $0x00c18148; WORD $0x0002; BYTE $0x00 // addq $512, %rcx - LONG $0xfcc68348 // addq $-4, %rsi - LONG $0xff6f850f; WORD $0xffff // jne LBB1_69, $-145(%rip) + LONG $0x04c68348 // addq $4, %rsi + LONG $0xff6f850f; WORD $0xffff // jne LBB1_71, $-145(%rip) -LBB1_70: +LBB1_72: WORD $0x854d; BYTE $0xc9 // testq %r9, %r9 - LONG $0x003c840f; WORD $0x0000 // je LBB1_73, $60(%rip) - WORD $0x014c; BYTE $0xe9 // addq %r13, %rcx - WORD $0x014c; BYTE $0xd1 // addq %r10, %rcx - LONG $0x62c18348 // addq $98, %rcx - LONG $0x07e1c149 // shlq $7, %r9 - WORD $0xf631 // xorl %esi, %esi - QUAD $0xfffff6b5056ffdc5 // vmovdqa $-2379(%rip), %ymm0 /* LCPI1_0(%rip) */ + LONG $0x0033840f; WORD $0x0000 // je LBB1_75, $51(%rip) + WORD $0x014c; BYTE $0xe1 // addq %r12, %rcx + LONG $0x0e4c8d49; BYTE $0x62 // leaq $98(%r14,%rcx), %rcx + WORD $0xf749; BYTE $0xd9 // negq %r9 + QUAD $0xfffff766056ffdc5 // vmovdqa $-2202(%rip), %ymm0 /* LCPI1_0(%rip) */ -LBB1_72: - LONG $0x447ffec5; WORD $0xa031 // vmovdqu %ymm0, $-96(%rcx,%rsi) - LONG $0x447ffec5; WORD $0xc031 // vmovdqu %ymm0, $-64(%rcx,%rsi) - LONG $0x447ffec5; WORD $0xe031 // vmovdqu %ymm0, $-32(%rcx,%rsi) - LONG $0x047ffec5; BYTE $0x31 // vmovdqu %ymm0, (%rcx,%rsi) - LONG $0x80ee8348 // subq $-128, %rsi - WORD $0x3949; BYTE $0xf1 // cmpq %rsi, %r9 - LONG $0xffdc850f; WORD $0xffff // jne LBB1_72, $-36(%rip) +LBB1_74: + LONG $0x417ffec5; BYTE $0xa0 // vmovdqu %ymm0, $-96(%rcx) + LONG $0x417ffec5; BYTE $0xc0 // vmovdqu %ymm0, $-64(%rcx) + LONG $0x417ffec5; BYTE $0xe0 // vmovdqu %ymm0, $-32(%rcx) + LONG $0x017ffec5 // vmovdqu %ymm0, (%rcx) + LONG $0x80e98348 // subq $-128, %rcx + WORD $0xff49; BYTE $0xc1 // incq %r9 + LONG $0xffe0850f; WORD $0xffff // jne LBB1_74, $-32(%rip) -LBB1_73: +LBB1_75: WORD $0x0149; BYTE $0xc7 // addq %rax, %r15 WORD $0x3949; BYTE $0xc0 // cmpq %rax, %r8 - LONG $0x0014840f; WORD $0x0000 // je LBB1_76, $20(%rip) + LONG $0x0019840f; WORD $0x0000 // je LBB1_78, $25(%rip) -LBB1_74: - WORD $0x0144; BYTE $0xf0 // addl %r14d, %eax - WORD $0xd8f7 // negl %eax +LBB1_76: + WORD $0x0144; BYTE $0xe8 // addl %r13d, %eax + WORD $0xd8f7 // negl %eax + LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 - // .p2align 4, 0x90 -LBB1_75: +LBB1_77: LONG $0x3007c641 // movb $48, (%r15) WORD $0xff49; BYTE $0xc7 // incq %r15 WORD $0xc8ff // decl %eax - LONG $0xfff1850f; WORD $0xffff // jne LBB1_75, $-15(%rip) + LONG $0xfff1850f; WORD $0xffff // jne LBB1_77, $-15(%rip) -LBB1_76: - WORD $0x894c; BYTE $0xfe // movq %r15, %rsi - WORD $0xf8c5; BYTE $0x77 // vzeroupper - LONG $0x008b66e8; BYTE $0x00 // callq _format_significand, $35686(%rip) - WORD $0xc389 // movl %eax, %ebx - WORD $0x2844; BYTE $0xfb // subb %r15b, %bl - WORD $0x2844; BYTE $0xf3 // subb %r14b, %bl - LONG $0x3e2c8d47 // leal (%r14,%r15), %r13d - WORD $0x2941; BYTE $0xc5 // subl %eax, %r13d - LONG $0xff458d45 // leal $-1(%r13), %r8d - LONG $0xfe7d8d41 // leal $-2(%r13), %edi - WORD $0xc931 // xorl %ecx, %ecx - QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 +LBB1_78: + WORD $0x894c; BYTE $0xfe // movq %r15, %rsi + WORD $0xf8c5; BYTE $0x77 // vzeroupper + LONG $0x0087a6e8; BYTE $0x00 // callq _format_significand, $34726(%rip) + LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 -LBB1_77: +LBB1_79: + LONG $0x30ff7880 // cmpb $48, $-1(%rax) + LONG $0xff408d48 // leaq $-1(%rax), %rax + LONG $0xfff2840f; WORD $0xffff // je LBB1_79, $-14(%rip) + LONG $0x01588d48 // leaq $1(%rax), %rbx + WORD $0x8545; BYTE $0xed // testl %r13d, %r13d + LONG $0x01f58e0f; WORD $0x0000 // jle LBB1_115, $501(%rip) WORD $0xda89 // movl %ebx, %edx - WORD $0x5a8d; BYTE $0x03 // leal $3(%rdx), %ebx - WORD $0xc7ff // incl %edi - LONG $0xff087c80; BYTE $0x30 // cmpb $48, $-1(%rax,%rcx) - LONG $0xff498d48 // leaq $-1(%rcx), %rcx - LONG $0xffea840f; WORD $0xffff // je LBB1_77, $-22(%rip) - LONG $0x081c8d48 // leaq (%rax,%rcx), %rbx - WORD $0xff48; BYTE $0xc3 // incq %rbx - WORD $0x8545; BYTE $0xf6 // testl %r14d, %r14d - LONG $0xd0558b4c // movq $-48(%rbp), %r10 - LONG $0x02778e0f; WORD $0x0000 // jle LBB1_122, $631(%rip) - WORD $0xc689 // movl %eax, %esi - WORD $0x2944; BYTE $0xfe // subl %r15d, %esi - WORD $0xce01 // addl %ecx, %esi - WORD $0xc6ff // incl %esi - WORD $0x3941; BYTE $0xf6 // cmpl %esi, %r14d - LONG $0x00308d0f; WORD $0x0000 // jge LBB1_80, $48(%rip) - WORD $0x8941; BYTE $0xc1 // movl %eax, %r9d - WORD $0x2945; BYTE $0xf1 // subl %r14d, %r9d - WORD $0x2945; BYTE $0xf9 // subl %r15d, %r9d - WORD $0xff41; BYTE $0xc1 // incl %r9d - LONG $0x093c8d49 // leaq (%r9,%rcx), %rdi - WORD $0xff85 // testl %edi, %edi - LONG $0x00e48e0f; WORD $0x0000 // jle LBB1_99, $228(%rip) - WORD $0x8941; BYTE $0xf8 // movl %edi, %r8d - LONG $0xff588d49 // leaq $-1(%r8), %rbx - LONG $0x03fb8348 // cmpq $3, %rbx - LONG $0x006c830f; WORD $0x0000 // jae LBB1_100, $108(%rip) - WORD $0xdb31 // xorl %ebx, %ebx - LONG $0x000090e9; BYTE $0x00 // jmp LBB1_96, $144(%rip) + WORD $0x2944; BYTE $0xfa // subl %r15d, %edx + WORD $0x8944; BYTE $0xe9 // movl %r13d, %ecx + WORD $0xd129 // subl %edx, %ecx + LONG $0x00258d0f; WORD $0x0000 // jge LBB1_82, $37(%rip) + WORD $0x2944; BYTE $0xea // subl %r13d, %edx + LONG $0x00c48e0f; WORD $0x0000 // jle LBB1_100, $196(%rip) + WORD $0xd689 // movl %edx, %esi + LONG $0xff568d48 // leaq $-1(%rsi), %rdx + WORD $0xf189 // movl %esi, %ecx + WORD $0xe183; BYTE $0x03 // andl $3, %ecx + LONG $0x03fa8348 // cmpq $3, %rdx + LONG $0x005c830f; WORD $0x0000 // jae LBB1_101, $92(%rip) + WORD $0xd231 // xorl %edx, %edx + LONG $0x000078e9; BYTE $0x00 // jmp LBB1_97, $120(%rip) -LBB1_80: - WORD $0x8945; BYTE $0xc3 // movl %r8d, %r11d - WORD $0x2949; BYTE $0xcb // subq %rcx, %r11 - WORD $0x8545; BYTE $0xdb // testl %r11d, %r11d - LONG $0x02268e0f; WORD $0x0000 // jle LBB1_122, $550(%rip) - WORD $0x0145; BYTE $0xfe // addl %r15d, %r14d - WORD $0x2941; BYTE $0xc6 // subl %eax, %r14d - LONG $0xfec68341 // addl $-2, %r14d - WORD $0x2949; BYTE $0xce // subq %rcx, %r14 +LBB1_82: + LONG $0x01ba8e0f; WORD $0x0000 // jle LBB1_115, $442(%rip) + WORD $0x0145; BYTE $0xfd // addl %r15d, %r13d + WORD $0x8941; BYTE $0xd8 // movl %ebx, %r8d + WORD $0xf741; BYTE $0xd0 // notl %r8d + WORD $0x0145; BYTE $0xe8 // addl %r13d, %r8d WORD $0xd231 // xorl %edx, %edx - LONG $0x7ffe8341 // cmpl $127, %r14d - LONG $0x01fc820f; WORD $0x0000 // jb LBB1_91, $508(%rip) - LONG $0xfec58341 // addl $-2, %r13d - WORD $0x2949; BYTE $0xcd // subq %rcx, %r13 - WORD $0x8945; BYTE $0xf0 // movl %r14d, %r8d + LONG $0x7ef88341 // cmpl $126, %r8d + LONG $0x0192860f; WORD $0x0000 // jbe LBB1_92, $402(%rip) WORD $0xff49; BYTE $0xc0 // incq %r8 - WORD $0x214d; BYTE $0xc4 // andq %r8, %r12 - WORD $0x8941; BYTE $0xf9 // movl %edi, %r9d - WORD $0xff49; BYTE $0xc1 // incq %r9 - LONG $0x80e18349 // andq $-128, %r9 - LONG $0x24548d49; BYTE $0x80 // leaq $-128(%r12), %rdx - WORD $0x8949; BYTE $0xd2 // movq %rdx, %r10 - LONG $0x07eac149 // shrq $7, %r10 - WORD $0xff49; BYTE $0xc2 // incq %r10 + QUAD $0x0001ffffff80b949; WORD $0x0000 // movabsq $8589934464, %r9 + WORD $0x214d; BYTE $0xc1 // andq %r8, %r9 + LONG $0x80518d49 // leaq $-128(%r9), %rdx + WORD $0x8948; BYTE $0xd7 // movq %rdx, %rdi + LONG $0x07efc148 // shrq $7, %rdi + WORD $0xff48; BYTE $0xc7 // incq %rdi + WORD $0xfe89 // movl %edi, %esi + WORD $0xe683; BYTE $0x03 // andl $3, %esi LONG $0x80fa8148; WORD $0x0001; BYTE $0x00 // cmpq $384, %rdx - LONG $0x0083830f; WORD $0x0000 // jae LBB1_84, $131(%rip) - WORD $0xff31 // xorl %edi, %edi - LONG $0x000138e9; BYTE $0x00 // jmp LBB1_86, $312(%rip) + LONG $0x006e830f; WORD $0x0000 // jae LBB1_86, $110(%rip) + WORD $0xd231 // xorl %edx, %edx + LONG $0x00010de9; BYTE $0x00 // jmp LBB1_88, $269(%rip) -LBB1_100: - WORD $0x0149; BYTE $0xc9 // addq %rcx, %r9 - LONG $0xfce18341 // andl $-4, %r9d - WORD $0xf749; BYTE $0xd9 // negq %r9 - WORD $0xdb31 // xorl %ebx, %ebx +LBB1_101: + WORD $0xe683; BYTE $0xfc // andl $-4, %esi + WORD $0xf748; BYTE $0xde // negq %rsi + WORD $0xd231 // xorl %edx, %edx WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 -LBB1_101: - LONG $0x183c8d48 // leaq (%rax,%rbx), %rdi - LONG $0xfd39748b // movl $-3(%rcx,%rdi), %esi - LONG $0xfe397489 // movl %esi, $-2(%rcx,%rdi) - LONG $0xfcc38348 // addq $-4, %rbx - WORD $0x3949; BYTE $0xd9 // cmpq %rbx, %r9 - LONG $0xffe7850f; WORD $0xffff // jne LBB1_101, $-25(%rip) - WORD $0xf748; BYTE $0xdb // negq %rbx - -LBB1_96: - LONG $0x03c0f641 // testb $3, %r8b - LONG $0x0032840f; WORD $0x0000 // je LBB1_99, $50(%rip) - LONG $0xc2b60f44 // movzbl %dl, %r8d - LONG $0x03e08341 // andl $3, %r8d - WORD $0xf749; BYTE $0xd8 // negq %r8 - WORD $0x8948; BYTE $0xc6 // movq %rax, %rsi - WORD $0x2948; BYTE $0xde // subq %rbx, %rsi - WORD $0xff31 // xorl %edi, %edi - LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 +LBB1_102: + LONG $0xfd107c8b // movl $-3(%rax,%rdx), %edi + LONG $0xfe107c89 // movl %edi, $-2(%rax,%rdx) + LONG $0xfcc28348 // addq $-4, %rdx + WORD $0x3948; BYTE $0xd6 // cmpq %rdx, %rsi + LONG $0xffeb850f; WORD $0xffff // jne LBB1_102, $-21(%rip) + WORD $0xf748; BYTE $0xda // negq %rdx -LBB1_98: - LONG $0x3e1c8d48 // leaq (%rsi,%rdi), %rbx - LONG $0x1914b60f // movzbl (%rcx,%rbx), %edx - LONG $0x01195488 // movb %dl, $1(%rcx,%rbx) - WORD $0xff48; BYTE $0xcf // decq %rdi - WORD $0x3949; BYTE $0xf8 // cmpq %rdi, %r8 - LONG $0xffe8850f; WORD $0xffff // jne LBB1_98, $-24(%rip) +LBB1_97: + WORD $0x8548; BYTE $0xc9 // testq %rcx, %rcx + LONG $0x0027840f; WORD $0x0000 // je LBB1_100, $39(%rip) + WORD $0xf748; BYTE $0xda // negq %rdx + WORD $0xf748; BYTE $0xd9 // negq %rcx + WORD $0xf631 // xorl %esi, %esi + LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 LBB1_99: - WORD $0x8944; BYTE $0xf2 // movl %r14d, %edx - LONG $0x1704c641; BYTE $0x2e // movb $46, (%r15,%rdx) - LONG $0x081c8d48 // leaq (%rax,%rcx), %rbx - LONG $0x02c38348 // addq $2, %rbx - LONG $0x000154e9; BYTE $0x00 // jmp LBB1_122, $340(%rip) - -LBB1_84: - WORD $0x8944; BYTE $0xeb // movl %r13d, %ebx - WORD $0xff48; BYTE $0xc3 // incq %rbx - LONG $0x80e38348 // andq $-128, %rbx - LONG $0x80c38348 // addq $-128, %rbx - LONG $0x07ebc148 // shrq $7, %rbx - WORD $0xff48; BYTE $0xc3 // incq %rbx - LONG $0xfce38348 // andq $-4, %rbx - WORD $0xff31 // xorl %edi, %edi - QUAD $0xfffff4d0056ffdc5 // vmovdqa $-2864(%rip), %ymm0 /* LCPI1_0(%rip) */ - -LBB1_85: - LONG $0x38148d48 // leaq (%rax,%rdi), %rdx - LONG $0x447ffec5; WORD $0x0111 // vmovdqu %ymm0, $1(%rcx,%rdx) - LONG $0x447ffec5; WORD $0x2111 // vmovdqu %ymm0, $33(%rcx,%rdx) - LONG $0x447ffec5; WORD $0x4111 // vmovdqu %ymm0, $65(%rcx,%rdx) - LONG $0x447ffec5; WORD $0x6111 // vmovdqu %ymm0, $97(%rcx,%rdx) - QUAD $0x00008111847ffec5; BYTE $0x00 // vmovdqu %ymm0, $129(%rcx,%rdx) - QUAD $0x0000a111847ffec5; BYTE $0x00 // vmovdqu %ymm0, $161(%rcx,%rdx) - QUAD $0x0000c111847ffec5; BYTE $0x00 // vmovdqu %ymm0, $193(%rcx,%rdx) - QUAD $0x0000e111847ffec5; BYTE $0x00 // vmovdqu %ymm0, $225(%rcx,%rdx) - QUAD $0x00010111847ffec5; BYTE $0x00 // vmovdqu %ymm0, $257(%rcx,%rdx) - QUAD $0x00012111847ffec5; BYTE $0x00 // vmovdqu %ymm0, $289(%rcx,%rdx) - QUAD $0x00014111847ffec5; BYTE $0x00 // vmovdqu %ymm0, $321(%rcx,%rdx) - QUAD $0x00016111847ffec5; BYTE $0x00 // vmovdqu %ymm0, $353(%rcx,%rdx) - QUAD $0x00018111847ffec5; BYTE $0x00 // vmovdqu %ymm0, $385(%rcx,%rdx) - QUAD $0x0001a111847ffec5; BYTE $0x00 // vmovdqu %ymm0, $417(%rcx,%rdx) - QUAD $0x0001c111847ffec5; BYTE $0x00 // vmovdqu %ymm0, $449(%rcx,%rdx) - QUAD $0x0001e111847ffec5; BYTE $0x00 // vmovdqu %ymm0, $481(%rcx,%rdx) - LONG $0x00c78148; WORD $0x0002; BYTE $0x00 // addq $512, %rdi - LONG $0xfcc38348 // addq $-4, %rbx - LONG $0xff67850f; WORD $0xffff // jne LBB1_85, $-153(%rip) + LONG $0x323c8d48 // leaq (%rdx,%rsi), %rdi + LONG $0x381cb60f // movzbl (%rax,%rdi), %ebx + LONG $0x01385c88 // movb %bl, $1(%rax,%rdi) + WORD $0xff48; BYTE $0xce // decq %rsi + WORD $0x3948; BYTE $0xf1 // cmpq %rsi, %rcx + LONG $0xffe8850f; WORD $0xffff // jne LBB1_99, $-24(%rip) + +LBB1_100: + WORD $0x6349; BYTE $0xcd // movslq %r13d, %rcx + LONG $0x0f04c641; BYTE $0x2e // movb $46, (%r15,%rcx) + LONG $0x02c08348 // addq $2, %rax + WORD $0x8948; BYTE $0xc3 // movq %rax, %rbx + LONG $0x000104e9; BYTE $0x00 // jmp LBB1_115, $260(%rip) LBB1_86: - WORD $0x0149; BYTE $0xc1 // addq %rax, %r9 - LONG $0x03c2f641 // testb $3, %r10b - LONG $0x0059840f; WORD $0x0000 // je LBB1_89, $89(%rip) - WORD $0xff41; BYTE $0xc5 // incl %r13d - LONG $0x80e58141; WORD $0x0001; BYTE $0x00 // andl $384, %r13d - LONG $0x80c58341 // addl $-128, %r13d - LONG $0x07edc141 // shrl $7, %r13d - WORD $0xfe41; BYTE $0xc5 // incb %r13b - LONG $0xd5b60f41 // movzbl %r13b, %edx - WORD $0xe283; BYTE $0x03 // andl $3, %edx - LONG $0x07e2c148 // shlq $7, %rdx - WORD $0x0148; BYTE $0xf8 // addq %rdi, %rax - LONG $0x61c08348 // addq $97, %rax - WORD $0xf631 // xorl %esi, %esi - QUAD $0xfffff3f9056ffdc5 // vmovdqa $-3079(%rip), %ymm0 /* LCPI1_0(%rip) */ + LONG $0xfce78348 // andq $-4, %rdi + WORD $0xf748; BYTE $0xdf // negq %rdi + WORD $0xd231 // xorl %edx, %edx + QUAD $0xfffff5f3056ffdc5 // vmovdqa $-2573(%rip), %ymm0 /* LCPI1_0(%rip) */ + +LBB1_87: + LONG $0x447ffec5; WORD $0x0110 // vmovdqu %ymm0, $1(%rax,%rdx) + LONG $0x447ffec5; WORD $0x2110 // vmovdqu %ymm0, $33(%rax,%rdx) + LONG $0x447ffec5; WORD $0x4110 // vmovdqu %ymm0, $65(%rax,%rdx) + LONG $0x447ffec5; WORD $0x6110 // vmovdqu %ymm0, $97(%rax,%rdx) + QUAD $0x00008110847ffec5; BYTE $0x00 // vmovdqu %ymm0, $129(%rax,%rdx) + QUAD $0x0000a110847ffec5; BYTE $0x00 // vmovdqu %ymm0, $161(%rax,%rdx) + QUAD $0x0000c110847ffec5; BYTE $0x00 // vmovdqu %ymm0, $193(%rax,%rdx) + QUAD $0x0000e110847ffec5; BYTE $0x00 // vmovdqu %ymm0, $225(%rax,%rdx) + QUAD $0x00010110847ffec5; BYTE $0x00 // vmovdqu %ymm0, $257(%rax,%rdx) + QUAD $0x00012110847ffec5; BYTE $0x00 // vmovdqu %ymm0, $289(%rax,%rdx) + QUAD $0x00014110847ffec5; BYTE $0x00 // vmovdqu %ymm0, $321(%rax,%rdx) + QUAD $0x00016110847ffec5; BYTE $0x00 // vmovdqu %ymm0, $353(%rax,%rdx) + QUAD $0x00018110847ffec5; BYTE $0x00 // vmovdqu %ymm0, $385(%rax,%rdx) + QUAD $0x0001a110847ffec5; BYTE $0x00 // vmovdqu %ymm0, $417(%rax,%rdx) + QUAD $0x0001c110847ffec5; BYTE $0x00 // vmovdqu %ymm0, $449(%rax,%rdx) + QUAD $0x0001e110847ffec5; BYTE $0x00 // vmovdqu %ymm0, $481(%rax,%rdx) + LONG $0x00c28148; WORD $0x0002; BYTE $0x00 // addq $512, %rdx + LONG $0x04c78348 // addq $4, %rdi + LONG $0xff6b850f; WORD $0xffff // jne LBB1_87, $-149(%rip) LBB1_88: - LONG $0x303c8d48 // leaq (%rax,%rsi), %rdi - LONG $0x447ffec5; WORD $0xa039 // vmovdqu %ymm0, $-96(%rcx,%rdi) - LONG $0x447ffec5; WORD $0xc039 // vmovdqu %ymm0, $-64(%rcx,%rdi) - LONG $0x447ffec5; WORD $0xe039 // vmovdqu %ymm0, $-32(%rcx,%rdi) - LONG $0x047ffec5; BYTE $0x39 // vmovdqu %ymm0, (%rcx,%rdi) - LONG $0x80ee8348 // subq $-128, %rsi - WORD $0x3948; BYTE $0xf2 // cmpq %rsi, %rdx - LONG $0xffd8850f; WORD $0xffff // jne LBB1_88, $-40(%rip) - -LBB1_89: - LONG $0x091c8d4a // leaq (%rcx,%r9), %rbx - WORD $0xff48; BYTE $0xc3 // incq %rbx - WORD $0x394d; BYTE $0xe0 // cmpq %r12, %r8 - LONG $0xd0558b4c // movq $-48(%rbp), %r10 - LONG $0x001e840f; WORD $0x0000 // je LBB1_122, $30(%rip) - WORD $0x8944; BYTE $0xe2 // movl %r12d, %edx - QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90 + LONG $0x085c8d4a; BYTE $0x01 // leaq $1(%rax,%r9), %rbx + WORD $0x8548; BYTE $0xf6 // testq %rsi, %rsi + LONG $0x0030840f; WORD $0x0000 // je LBB1_91, $48(%rip) + LONG $0x10448d48; BYTE $0x61 // leaq $97(%rax,%rdx), %rax + WORD $0xf748; BYTE $0xde // negq %rsi + QUAD $0xfffff540056ffdc5 // vmovdqa $-2752(%rip), %ymm0 /* LCPI1_0(%rip) */ + +LBB1_90: + LONG $0x407ffec5; BYTE $0xa0 // vmovdqu %ymm0, $-96(%rax) + LONG $0x407ffec5; BYTE $0xc0 // vmovdqu %ymm0, $-64(%rax) + LONG $0x407ffec5; BYTE $0xe0 // vmovdqu %ymm0, $-32(%rax) + LONG $0x007ffec5 // vmovdqu %ymm0, (%rax) + LONG $0x80e88348 // subq $-128, %rax + WORD $0xff48; BYTE $0xc6 // incq %rsi + LONG $0xffe0850f; WORD $0xffff // jne LBB1_90, $-32(%rip) LBB1_91: + WORD $0x8944; BYTE $0xca // movl %r9d, %edx + WORD $0x394d; BYTE $0xc8 // cmpq %r9, %r8 + LONG $0x0014840f; WORD $0x0000 // je LBB1_115, $20(%rip) + LONG $0x90909090 // .p2align 4, 0x90 + +LBB1_92: WORD $0x03c6; BYTE $0x30 // movb $48, (%rbx) WORD $0xff48; BYTE $0xc3 // incq %rbx WORD $0xc2ff // incl %edx - WORD $0x3944; BYTE $0xda // cmpl %r11d, %edx - LONG $0xffef8c0f; WORD $0xffff // jl LBB1_91, $-17(%rip) + WORD $0xca39 // cmpl %ecx, %edx + LONG $0xfff08c0f; WORD $0xffff // jl LBB1_92, $-16(%rip) -LBB1_122: - WORD $0x2944; BYTE $0xd3 // subl %r10d, %ebx +LBB1_115: + WORD $0x2944; BYTE $0xf3 // subl %r14d, %ebx -LBB1_123: +LBB1_116: WORD $0xd889 // movl %ebx, %eax LONG $0x08c48348 // addq $8, %rsp BYTE $0x5b // popq %rbx @@ -1000,19 +830,24 @@ LBB1_123: WORD $0xf8c5; BYTE $0x77 // vzeroupper BYTE $0xc3 // retq +LBB1_49: + LONG $0x00ff8148; WORD $0x9aca; BYTE $0x3b // cmpq $1000000000, %rdi + LONG $0x00000aba; BYTE $0x00 // movl $10, %edx + LONG $0xfff7e6e9; BYTE $0xff // jmp LBB1_50, $-2074(%rip) + LBB1_1: WORD $0xdb31 // xorl %ebx, %ebx - LONG $0xffffe5e9; BYTE $0xff // jmp LBB1_123, $-27(%rip) + LONG $0xffffd4e9; BYTE $0xff // jmp LBB1_116, $-44(%rip) LBB1_5: - LONG $0xfffbcebe; BYTE $0xff // movl $-1074, %esi + LONG $0xfffbcebb; BYTE $0xff // movl $-1074, %ebx WORD $0x8948; BYTE $0xd7 // movq %rdx, %rdi - LONG $0xfff441e9; BYTE $0xff // jmp LBB1_6, $-3007(%rip) + LONG $0xfff57ae9; BYTE $0xff // jmp LBB1_6, $-2694(%rip) -LBB1_25: +LBB1_26: LONG $0x00ff8148; WORD $0x9aca; BYTE $0x3b // cmpq $1000000000, %rdi LONG $0x00000aba; BYTE $0x00 // movl $10, %edx - LONG $0xfff8dfe9; BYTE $0xff // jmp LBB1_26, $-1825(%rip) + LONG $0xfffa30e9; BYTE $0xff // jmp LBB1_27, $-1488(%rip) WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 _format_integer: @@ -1064,7 +899,7 @@ LBB2_2: WORD $0xcf6b; BYTE $0x64 // imull $100, %edi, %ecx WORD $0xc829 // subl %ecx, %eax LONG $0xd8b70f44 // movzwl %ax, %r11d - LONG $0x500d8d48; WORD $0x00bf; BYTE $0x00 // leaq $48976(%rip), %rcx /* _Digits(%rip) */ + LONG $0xe00d8d48; WORD $0x00b8; BYTE $0x00 // leaq $47328(%rip), %rcx /* _Digits(%rip) */ LONG $0x04b70f42; BYTE $0x51 // movzwl (%rcx,%r10,2), %eax LONG $0x40894166; BYTE $0xfe // movw %ax, $-2(%r8) LONG $0x04b70f42; BYTE $0x49 // movzwl (%rcx,%r9,2), %eax @@ -1080,7 +915,7 @@ LBB2_2: LBB2_5: LONG $0x1759b941; WORD $0xd1b7 // movl $3518437209, %r9d - LONG $0x09158d4c; WORD $0x00bf; BYTE $0x00 // leaq $48905(%rip), %r10 /* _Digits(%rip) */ + LONG $0x99158d4c; WORD $0x00b8; BYTE $0x00 // leaq $47257(%rip), %r10 /* _Digits(%rip) */ QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90 LBB2_6: @@ -1112,7 +947,7 @@ LBB2_7: WORD $0xc86b; BYTE $0x64 // imull $100, %eax, %ecx WORD $0xca29 // subl %ecx, %edx WORD $0xb70f; BYTE $0xca // movzwl %dx, %ecx - LONG $0x91158d48; WORD $0x00be; BYTE $0x00 // leaq $48785(%rip), %rdx /* _Digits(%rip) */ + LONG $0x21158d48; WORD $0x00b8; BYTE $0x00 // leaq $47137(%rip), %rdx /* _Digits(%rip) */ LONG $0x4a0cb70f // movzwl (%rdx,%rcx,2), %ecx LONG $0x4b894166; BYTE $0xfe // movw %cx, $-2(%r11) LONG $0xfec38349 // addq $-2, %r11 @@ -1122,7 +957,7 @@ LBB2_9: WORD $0xfa83; BYTE $0x0a // cmpl $10, %edx LONG $0x0018820f; WORD $0x0000 // jb LBB2_11, $24(%rip) WORD $0xd089 // movl %edx, %eax - LONG $0x700d8d48; WORD $0x00be; BYTE $0x00 // leaq $48752(%rip), %rcx /* _Digits(%rip) */ + LONG $0x000d8d48; WORD $0x00b8; BYTE $0x00 // leaq $47104(%rip), %rcx /* _Digits(%rip) */ LONG $0x4104b70f // movzwl (%rcx,%rax,2), %eax LONG $0x43894166; BYTE $0xfe // movw %ax, $-2(%r11) WORD $0x894c; BYTE $0xc0 // movq %r8, %rax @@ -1140,100 +975,52 @@ LBB2_11: LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 _i64toa: + WORD $0x8548; BYTE $0xf6 // testq %rsi, %rsi + LONG $0x0005880f; WORD $0x0000 // js LBB3_1, $5(%rip) + LONG $0x000062e9; BYTE $0x00 // jmp _u64toa, $98(%rip) + +LBB3_1: BYTE $0x55 // pushq %rbp WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp - WORD $0x8548; BYTE $0xf6 // testq %rsi, %rsi - LONG $0x00b1880f; WORD $0x0000 // js LBB3_12, $177(%rip) - LONG $0x0ffe8148; WORD $0x0027; BYTE $0x00 // cmpq $9999, %rsi - LONG $0x00b6870f; WORD $0x0000 // ja LBB3_9, $182(%rip) - WORD $0xb70f; BYTE $0xc6 // movzwl %si, %eax - WORD $0xe8c1; BYTE $0x02 // shrl $2, %eax - LONG $0x147bc069; WORD $0x0000 // imull $5243, %eax, %eax - WORD $0xe8c1; BYTE $0x11 // shrl $17, %eax - LONG $0x00148d48 // leaq (%rax,%rax), %rdx - WORD $0xc06b; BYTE $0x64 // imull $100, %eax, %eax - WORD $0xf189 // movl %esi, %ecx - WORD $0xc129 // subl %eax, %ecx - WORD $0xb70f; BYTE $0xc9 // movzwl %cx, %ecx - WORD $0x0148; BYTE $0xc9 // addq %rcx, %rcx - LONG $0x03e8fe81; WORD $0x0000 // cmpl $1000, %esi - LONG $0x0017820f; WORD $0x0000 // jb LBB3_4, $23(%rip) - LONG $0x03058d48; WORD $0x00be; BYTE $0x00 // leaq $48643(%rip), %rax /* _Digits(%rip) */ - LONG $0x0204b60f // movzbl (%rdx,%rax), %eax - WORD $0x0788 // movb %al, (%rdi) - LONG $0x000001b8; BYTE $0x00 // movl $1, %eax - LONG $0x00000be9; BYTE $0x00 // jmp LBB3_5, $11(%rip) - -LBB3_4: - WORD $0xc031 // xorl %eax, %eax - WORD $0xfe83; BYTE $0x64 // cmpl $100, %esi - LONG $0x0046820f; WORD $0x0000 // jb LBB3_6, $70(%rip) - -LBB3_5: - WORD $0xb70f; BYTE $0xd2 // movzwl %dx, %edx - LONG $0x01ca8348 // orq $1, %rdx - LONG $0xda358d48; WORD $0x00bd; BYTE $0x00 // leaq $48602(%rip), %rsi /* _Digits(%rip) */ - LONG $0x3214b60f // movzbl (%rdx,%rsi), %edx - WORD $0xc689 // movl %eax, %esi - WORD $0xc0ff // incl %eax - WORD $0x1488; BYTE $0x37 // movb %dl, (%rdi,%rsi) - -LBB3_7: - LONG $0xc8158d48; WORD $0x00bd; BYTE $0x00 // leaq $48584(%rip), %rdx /* _Digits(%rip) */ - LONG $0x1114b60f // movzbl (%rcx,%rdx), %edx - WORD $0xc689 // movl %eax, %esi - WORD $0xc0ff // incl %eax - WORD $0x1488; BYTE $0x37 // movb %dl, (%rdi,%rsi) - -LBB3_8: - WORD $0xb70f; BYTE $0xc9 // movzwl %cx, %ecx - LONG $0x01c98348 // orq $1, %rcx - LONG $0xaf158d48; WORD $0x00bd; BYTE $0x00 // leaq $48559(%rip), %rdx /* _Digits(%rip) */ - LONG $0x110cb60f // movzbl (%rcx,%rdx), %ecx - WORD $0xc289 // movl %eax, %edx + WORD $0x07c6; BYTE $0x2d // movb $45, (%rdi) + WORD $0xff48; BYTE $0xc7 // incq %rdi + WORD $0xf748; BYTE $0xde // negq %rsi + LONG $0x000050e8; BYTE $0x00 // callq _u64toa, $80(%rip) WORD $0xc0ff // incl %eax - WORD $0x0c88; BYTE $0x17 // movb %cl, (%rdi,%rdx) BYTE $0x5d // popq %rbp BYTE $0xc3 // retq + QUAD $0x0000000000000000; LONG $0x00000000 // .p2align 4, 0x00 -LBB3_6: - WORD $0xc031 // xorl %eax, %eax - WORD $0xfe83; BYTE $0x0a // cmpl $10, %esi - LONG $0xffc8830f; WORD $0xffff // jae LBB3_7, $-56(%rip) - LONG $0xffffd5e9; BYTE $0xff // jmp LBB3_8, $-43(%rip) +LCPI4_0: + QUAD $0x00000000d1b71759 // .quad 3518437209 + QUAD $0x00000000d1b71759 // .quad 3518437209 -LBB3_12: - WORD $0x07c6; BYTE $0x2d // movb $45, (%rdi) - WORD $0xff48; BYTE $0xc7 // incq %rdi - WORD $0xf748; BYTE $0xde // negq %rsi - LONG $0x000044e8; BYTE $0x00 // callq _u64toa, $68(%rip) - WORD $0xc0ff // incl %eax - BYTE $0x5d // popq %rbp - BYTE $0xc3 // retq +LCPI4_3: + WORD $0x000a // .word 10 + WORD $0x000a // .word 10 + WORD $0x000a // .word 10 + WORD $0x000a // .word 10 + WORD $0x000a // .word 10 + WORD $0x000a // .word 10 + WORD $0x000a // .word 10 + WORD $0x000a // .word 10 -LBB3_9: - LONG $0xfffe8148; WORD $0xf5e0; BYTE $0x05 // cmpq $99999999, %rsi - LONG $0x0006870f; WORD $0x0000 // ja LBB3_10, $6(%rip) - BYTE $0x5d // popq %rbp - LONG $0x00011de9; BYTE $0x00 // jmp _u32toa_medium, $285(%rip) +LCPI4_4: + QUAD $0x3030303030303030; QUAD $0x3030303030303030 // .space 16, '0000000000000000' -LBB3_10: - QUAD $0x86f26fc0ffffb848; WORD $0x0023 // movabsq $9999999999999999, %rax - WORD $0x3948; BYTE $0xc6 // cmpq %rax, %rsi - LONG $0x0006870f; WORD $0x0000 // ja LBB3_11, $6(%rip) - BYTE $0x5d // popq %rbp - LONG $0x000244e9; BYTE $0x00 // jmp _u64toa_large_sse2, $580(%rip) + // .p2align 3, 0x00 +LCPI4_1: + QUAD $0x80003334147b20c5 // .quad -9223315738079846203 -LBB3_11: - BYTE $0x5d // popq %rbp - LONG $0x00038ee9; BYTE $0x00 // jmp _u64toa_xlarge_sse2, $910(%rip) - QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 +LCPI4_2: + QUAD $0x8000200008000080 // .quad -9223336852348469120 + // .p2align 4, 0x90 _u64toa: - LONG $0x0ffe8148; WORD $0x0027; BYTE $0x00 // cmpq $9999, %rsi - LONG $0x00a8870f; WORD $0x0000 // ja LBB4_8, $168(%rip) BYTE $0x55 // pushq %rbp WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + LONG $0x0ffe8148; WORD $0x0027; BYTE $0x00 // cmpq $9999, %rsi + LONG $0x00a2870f; WORD $0x0000 // ja LBB4_8, $162(%rip) WORD $0xb70f; BYTE $0xc6 // movzwl %si, %eax WORD $0xe8c1; BYTE $0x02 // shrl $2, %eax LONG $0x147bc069; WORD $0x0000 // imull $5243, %eax, %eax @@ -1242,173 +1029,148 @@ _u64toa: WORD $0xc06b; BYTE $0x64 // imull $100, %eax, %eax WORD $0xf189 // movl %esi, %ecx WORD $0xc129 // subl %eax, %ecx - WORD $0xb70f; BYTE $0xc9 // movzwl %cx, %ecx - WORD $0x0148; BYTE $0xc9 // addq %rcx, %rcx + WORD $0xb70f; BYTE $0xc1 // movzwl %cx, %eax + WORD $0x0148; BYTE $0xc0 // addq %rax, %rax LONG $0x03e8fe81; WORD $0x0000 // cmpl $1000, %esi - LONG $0x0017820f; WORD $0x0000 // jb LBB4_3, $23(%rip) - LONG $0xfc058d48; WORD $0x00bc; BYTE $0x00 // leaq $48380(%rip), %rax /* _Digits(%rip) */ - LONG $0x0204b60f // movzbl (%rdx,%rax), %eax - WORD $0x0788 // movb %al, (%rdi) - LONG $0x000001b8; BYTE $0x00 // movl $1, %eax + LONG $0x0016820f; WORD $0x0000 // jb LBB4_3, $22(%rip) + LONG $0x2c0d8d48; WORD $0x00b7; BYTE $0x00 // leaq $46892(%rip), %rcx /* _Digits(%rip) */ + WORD $0x0c8a; BYTE $0x0a // movb (%rdx,%rcx), %cl + WORD $0x0f88 // movb %cl, (%rdi) + LONG $0x000001b9; BYTE $0x00 // movl $1, %ecx LONG $0x00000be9; BYTE $0x00 // jmp LBB4_4, $11(%rip) LBB4_3: - WORD $0xc031 // xorl %eax, %eax + WORD $0xc931 // xorl %ecx, %ecx WORD $0xfe83; BYTE $0x64 // cmpl $100, %esi - LONG $0x0046820f; WORD $0x0000 // jb LBB4_5, $70(%rip) + LONG $0x0045820f; WORD $0x0000 // jb LBB4_5, $69(%rip) LBB4_4: WORD $0xb70f; BYTE $0xd2 // movzwl %dx, %edx LONG $0x01ca8348 // orq $1, %rdx - LONG $0xd3358d48; WORD $0x00bc; BYTE $0x00 // leaq $48339(%rip), %rsi /* _Digits(%rip) */ - LONG $0x3214b60f // movzbl (%rdx,%rsi), %edx - WORD $0xc689 // movl %eax, %esi - WORD $0xc0ff // incl %eax + LONG $0x04358d48; WORD $0x00b7; BYTE $0x00 // leaq $46852(%rip), %rsi /* _Digits(%rip) */ + WORD $0x148a; BYTE $0x32 // movb (%rdx,%rsi), %dl + WORD $0xce89 // movl %ecx, %esi + WORD $0xc1ff // incl %ecx WORD $0x1488; BYTE $0x37 // movb %dl, (%rdi,%rsi) LBB4_6: - LONG $0xc1158d48; WORD $0x00bc; BYTE $0x00 // leaq $48321(%rip), %rdx /* _Digits(%rip) */ - LONG $0x1114b60f // movzbl (%rcx,%rdx), %edx - WORD $0xc689 // movl %eax, %esi - WORD $0xc0ff // incl %eax + LONG $0xf3158d48; WORD $0x00b6; BYTE $0x00 // leaq $46835(%rip), %rdx /* _Digits(%rip) */ + WORD $0x148a; BYTE $0x10 // movb (%rax,%rdx), %dl + WORD $0xce89 // movl %ecx, %esi + WORD $0xc1ff // incl %ecx WORD $0x1488; BYTE $0x37 // movb %dl, (%rdi,%rsi) LBB4_7: - WORD $0xb70f; BYTE $0xc9 // movzwl %cx, %ecx - LONG $0x01c98348 // orq $1, %rcx - LONG $0xa8158d48; WORD $0x00bc; BYTE $0x00 // leaq $48296(%rip), %rdx /* _Digits(%rip) */ - LONG $0x110cb60f // movzbl (%rcx,%rdx), %ecx - WORD $0xc289 // movl %eax, %edx - WORD $0xc0ff // incl %eax - WORD $0x0c88; BYTE $0x17 // movb %cl, (%rdi,%rdx) + WORD $0xb70f; BYTE $0xc0 // movzwl %ax, %eax + LONG $0x01c88348 // orq $1, %rax + LONG $0xdb158d48; WORD $0x00b6; BYTE $0x00 // leaq $46811(%rip), %rdx /* _Digits(%rip) */ + WORD $0x048a; BYTE $0x10 // movb (%rax,%rdx), %al + WORD $0xca89 // movl %ecx, %edx + WORD $0xc1ff // incl %ecx + WORD $0x0488; BYTE $0x17 // movb %al, (%rdi,%rdx) + WORD $0xc889 // movl %ecx, %eax BYTE $0x5d // popq %rbp BYTE $0xc3 // retq LBB4_5: - WORD $0xc031 // xorl %eax, %eax + WORD $0xc931 // xorl %ecx, %ecx WORD $0xfe83; BYTE $0x0a // cmpl $10, %esi LONG $0xffc8830f; WORD $0xffff // jae LBB4_6, $-56(%rip) - LONG $0xffffd5e9; BYTE $0xff // jmp LBB4_7, $-43(%rip) + LONG $0xffffd4e9; BYTE $0xff // jmp LBB4_7, $-44(%rip) LBB4_8: LONG $0xfffe8148; WORD $0xf5e0; BYTE $0x05 // cmpq $99999999, %rsi - LONG $0x0005870f; WORD $0x0000 // ja LBB4_9, $5(%rip) - LONG $0x000029e9; BYTE $0x00 // jmp _u32toa_medium, $41(%rip) - -LBB4_9: - QUAD $0x86f26fc0ffffb848; WORD $0x0023 // movabsq $9999999999999999, %rax - WORD $0x3948; BYTE $0xc6 // cmpq %rax, %rsi - LONG $0x0005870f; WORD $0x0000 // ja LBB4_10, $5(%rip) - LONG $0x000151e9; BYTE $0x00 // jmp _u64toa_large_sse2, $337(%rip) - -LBB4_10: - LONG $0x00029ce9; BYTE $0x00 // jmp _u64toa_xlarge_sse2, $668(%rip) - QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90 - -_u32toa_medium: - BYTE $0x55 // pushq %rbp - WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + LONG $0x011e870f; WORD $0x0000 // ja LBB4_16, $286(%rip) WORD $0xf089 // movl %esi, %eax - LONG $0xb71759b9; BYTE $0xd1 // movl $3518437209, %ecx - LONG $0xc8af0f48 // imulq %rax, %rcx - LONG $0x2de9c148 // shrq $45, %rcx - LONG $0x2710d169; WORD $0x0000 // imull $10000, %ecx, %edx - WORD $0x8941; BYTE $0xf0 // movl %esi, %r8d - WORD $0x2941; BYTE $0xd0 // subl %edx, %r8d - LONG $0x83d06948; WORD $0x1bde; BYTE $0x43 // imulq $1125899907, %rax, %rdx - LONG $0x31eac148 // shrq $49, %rdx - WORD $0xe283; BYTE $0xfe // andl $-2, %edx - LONG $0x1fc16948; WORD $0xeb85; BYTE $0x51 // imulq $1374389535, %rcx, %rax - LONG $0x25e8c148 // shrq $37, %rax + LONG $0xb71759ba; BYTE $0xd1 // movl $3518437209, %edx + LONG $0xd0af0f48 // imulq %rax, %rdx + LONG $0x2deac148 // shrq $45, %rdx + LONG $0x10c26944; WORD $0x0027; BYTE $0x00 // imull $10000, %edx, %r8d + WORD $0xf189 // movl %esi, %ecx + WORD $0x2944; BYTE $0xc1 // subl %r8d, %ecx + LONG $0x83d0694c; WORD $0x1bde; BYTE $0x43 // imulq $1125899907, %rax, %r10 + LONG $0x31eac149 // shrq $49, %r10 + LONG $0xfee28341 // andl $-2, %r10d + WORD $0xb70f; BYTE $0xc2 // movzwl %dx, %eax + WORD $0xe8c1; BYTE $0x02 // shrl $2, %eax + LONG $0x147bc069; WORD $0x0000 // imull $5243, %eax, %eax + WORD $0xe8c1; BYTE $0x11 // shrl $17, %eax + WORD $0xc06b; BYTE $0x64 // imull $100, %eax, %eax + WORD $0xc229 // subl %eax, %edx + LONG $0xcab70f44 // movzwl %dx, %r9d + WORD $0x014d; BYTE $0xc9 // addq %r9, %r9 + WORD $0xb70f; BYTE $0xc1 // movzwl %cx, %eax + WORD $0xe8c1; BYTE $0x02 // shrl $2, %eax + LONG $0x147bc069; WORD $0x0000 // imull $5243, %eax, %eax + WORD $0xe8c1; BYTE $0x11 // shrl $17, %eax + LONG $0x00048d4c // leaq (%rax,%rax), %r8 WORD $0xc06b; BYTE $0x64 // imull $100, %eax, %eax WORD $0xc129 // subl %eax, %ecx - WORD $0x0148; BYTE $0xc9 // addq %rcx, %rcx + LONG $0xd9b70f44 // movzwl %cx, %r11d + WORD $0x014d; BYTE $0xdb // addq %r11, %r11 LONG $0x9680fe81; WORD $0x0098 // cmpl $10000000, %esi - LONG $0x0017820f; WORD $0x0000 // jb LBB5_2, $23(%rip) - LONG $0xfd058d48; WORD $0x00bb; BYTE $0x00 // leaq $48125(%rip), %rax /* _Digits(%rip) */ - LONG $0x0204b60f // movzbl (%rdx,%rax), %eax + LONG $0x0017820f; WORD $0x0000 // jb LBB4_11, $23(%rip) + LONG $0x39058d48; WORD $0x00b6; BYTE $0x00 // leaq $46649(%rip), %rax /* _Digits(%rip) */ + LONG $0x02048a41 // movb (%r10,%rax), %al WORD $0x0788 // movb %al, (%rdi) - LONG $0x000001b8; BYTE $0x00 // movl $1, %eax - LONG $0x00000ee9; BYTE $0x00 // jmp LBB5_3, $14(%rip) + LONG $0x000001b9; BYTE $0x00 // movl $1, %ecx + LONG $0x00000ee9; BYTE $0x00 // jmp LBB4_12, $14(%rip) -LBB5_2: - WORD $0xc031 // xorl %eax, %eax +LBB4_11: + WORD $0xc931 // xorl %ecx, %ecx LONG $0x4240fe81; WORD $0x000f // cmpl $1000000, %esi - LONG $0x0074820f; WORD $0x0000 // jb LBB5_4, $116(%rip) + LONG $0x0076820f; WORD $0x0000 // jb LBB4_13, $118(%rip) -LBB5_3: - WORD $0xd289 // movl %edx, %edx - LONG $0x01ca8348 // orq $1, %rdx - LONG $0xd2358d48; WORD $0x00bb; BYTE $0x00 // leaq $48082(%rip), %rsi /* _Digits(%rip) */ - LONG $0x3214b60f // movzbl (%rdx,%rsi), %edx - WORD $0xc689 // movl %eax, %esi - WORD $0xc0ff // incl %eax - WORD $0x1488; BYTE $0x37 // movb %dl, (%rdi,%rsi) - -LBB5_5: - LONG $0xc0158d48; WORD $0x00bb; BYTE $0x00 // leaq $48064(%rip), %rdx /* _Digits(%rip) */ - LONG $0x1114b60f // movzbl (%rcx,%rdx), %edx - WORD $0xc689 // movl %eax, %esi - WORD $0xc0ff // incl %eax - WORD $0x1488; BYTE $0x37 // movb %dl, (%rdi,%rsi) +LBB4_12: + WORD $0x8944; BYTE $0xd0 // movl %r10d, %eax + LONG $0x01c88348 // orq $1, %rax + LONG $0x0d358d48; WORD $0x00b6; BYTE $0x00 // leaq $46605(%rip), %rsi /* _Digits(%rip) */ + WORD $0x048a; BYTE $0x30 // movb (%rax,%rsi), %al + WORD $0xce89 // movl %ecx, %esi + WORD $0xc1ff // incl %ecx + WORD $0x0488; BYTE $0x37 // movb %al, (%rdi,%rsi) -LBB5_6: - LONG $0xd0b70f41 // movzwl %r8w, %edx - WORD $0xeac1; BYTE $0x02 // shrl $2, %edx - LONG $0x147bd269; WORD $0x0000 // imull $5243, %edx, %edx - WORD $0xeac1; BYTE $0x11 // shrl $17, %edx - WORD $0xf26b; BYTE $0x64 // imull $100, %edx, %esi - WORD $0x2941; BYTE $0xf0 // subl %esi, %r8d - LONG $0xc0b70f45 // movzwl %r8w, %r8d - WORD $0xc989 // movl %ecx, %ecx - LONG $0x01c98348 // orq $1, %rcx - LONG $0x8e0d8d4c; WORD $0x00bb; BYTE $0x00 // leaq $48014(%rip), %r9 /* _Digits(%rip) */ - LONG $0x0cb60f42; BYTE $0x09 // movzbl (%rcx,%r9), %ecx - WORD $0xc689 // movl %eax, %esi - WORD $0x0c88; BYTE $0x37 // movb %cl, (%rdi,%rsi) - LONG $0x0cb70f41; BYTE $0x51 // movzwl (%r9,%rdx,2), %ecx - LONG $0x374c8966; BYTE $0x01 // movw %cx, $1(%rdi,%rsi) - LONG $0x0cb70f43; BYTE $0x41 // movzwl (%r9,%r8,2), %ecx - LONG $0x374c8966; BYTE $0x03 // movw %cx, $3(%rdi,%rsi) - WORD $0xc083; BYTE $0x05 // addl $5, %eax +LBB4_14: + LONG $0xfc058d48; WORD $0x00b5; BYTE $0x00 // leaq $46588(%rip), %rax /* _Digits(%rip) */ + LONG $0x01048a41 // movb (%r9,%rax), %al + WORD $0xce89 // movl %ecx, %esi + WORD $0xc1ff // incl %ecx + WORD $0x0488; BYTE $0x37 // movb %al, (%rdi,%rsi) + +LBB4_15: + LONG $0xc1b70f41 // movzwl %r9w, %eax + LONG $0x01c88348 // orq $1, %rax + LONG $0xe2358d48; WORD $0x00b5; BYTE $0x00 // leaq $46562(%rip), %rsi /* _Digits(%rip) */ + WORD $0x048a; BYTE $0x30 // movb (%rax,%rsi), %al + WORD $0xca89 // movl %ecx, %edx + WORD $0x0488; BYTE $0x17 // movb %al, (%rdi,%rdx) + LONG $0x30048a41 // movb (%r8,%rsi), %al + LONG $0x01174488 // movb %al, $1(%rdi,%rdx) + LONG $0xc0b70f41 // movzwl %r8w, %eax + LONG $0x01c88348 // orq $1, %rax + WORD $0x048a; BYTE $0x30 // movb (%rax,%rsi), %al + LONG $0x02174488 // movb %al, $2(%rdi,%rdx) + LONG $0x33048a41 // movb (%r11,%rsi), %al + LONG $0x03174488 // movb %al, $3(%rdi,%rdx) + LONG $0xc3b70f41 // movzwl %r11w, %eax + LONG $0x01c88348 // orq $1, %rax + WORD $0x048a; BYTE $0x30 // movb (%rax,%rsi), %al + WORD $0xc183; BYTE $0x05 // addl $5, %ecx + LONG $0x04174488 // movb %al, $4(%rdi,%rdx) + WORD $0xc889 // movl %ecx, %eax BYTE $0x5d // popq %rbp BYTE $0xc3 // retq -LBB5_4: - WORD $0xc031 // xorl %eax, %eax +LBB4_13: + WORD $0xc931 // xorl %ecx, %ecx LONG $0x86a0fe81; WORD $0x0001 // cmpl $100000, %esi - LONG $0xff96830f; WORD $0xffff // jae LBB5_5, $-106(%rip) - LONG $0xffffa3e9; BYTE $0xff // jmp LBB5_6, $-93(%rip) - QUAD $0x0000000000000000 // .p2align 4, 0x00 - -LCPI6_0: - QUAD $0x00000000d1b71759 // .quad 3518437209 - QUAD $0x00000000d1b71759 // .quad 3518437209 - -LCPI6_3: - WORD $0x000a // .word 10 - WORD $0x000a // .word 10 - WORD $0x000a // .word 10 - WORD $0x000a // .word 10 - WORD $0x000a // .word 10 - WORD $0x000a // .word 10 - WORD $0x000a // .word 10 - WORD $0x000a // .word 10 - -LCPI6_4: - QUAD $0x3030303030303030; QUAD $0x3030303030303030 // .space 16, '0000000000000000' - - // .p2align 3, 0x00 -LCPI6_1: - QUAD $0x80003334147b20c5 // .quad -9223315738079846203 - -LCPI6_2: - QUAD $0x8000200008000080 // .quad -9223336852348469120 + LONG $0xff94830f; WORD $0xffff // jae LBB4_14, $-108(%rip) + LONG $0xffffa1e9; BYTE $0xff // jmp LBB4_15, $-95(%rip) - // .p2align 4, 0x90 -_u64toa_large_sse2: - BYTE $0x55 // pushq %rbp - WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp +LBB4_16: + QUAD $0x86f26fc0ffffb848; WORD $0x0023 // movabsq $9999999999999999, %rax + WORD $0x3948; BYTE $0xc6 // cmpq %rax, %rsi + LONG $0x0107870f; WORD $0x0000 // ja LBB4_18, $263(%rip) QUAD $0x77118461cefdb948; WORD $0xabcc // movabsq $-6067343680855748867, %rcx WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax WORD $0xf748; BYTE $0xe1 // mulq %rcx @@ -1416,7 +1178,7 @@ _u64toa_large_sse2: LONG $0xe100c269; WORD $0x05f5 // imull $100000000, %edx, %eax WORD $0xc629 // subl %eax, %esi LONG $0xc26ef9c5 // vmovd %edx, %xmm0 - QUAD $0xffffff940d6ff9c5 // vmovdqa $-108(%rip), %xmm1 /* LCPI6_0(%rip) */ + QUAD $0xfffffda70d6ff9c5 // vmovdqa $-601(%rip), %xmm1 /* LCPI4_0(%rip) */ LONG $0xd1f4f9c5 // vpmuludq %xmm1, %xmm0, %xmm2 LONG $0xd273e9c5; BYTE $0x2d // vpsrlq $45, %xmm2, %xmm2 LONG $0x002710b8; BYTE $0x00 // movl $10000, %eax @@ -1427,11 +1189,11 @@ _u64toa_large_sse2: LONG $0xf073f9c5; BYTE $0x02 // vpsllq $2, %xmm0, %xmm0 LONG $0xc070fbc5; BYTE $0x50 // vpshuflw $80, %xmm0, %xmm0 LONG $0xc070f9c5; BYTE $0x50 // vpshufd $80, %xmm0, %xmm0 - QUAD $0xffff8d155979e2c4; BYTE $0xff // vpbroadcastq $-115(%rip), %xmm2 /* LCPI6_1(%rip) */ + QUAD $0xfffda0155979e2c4; BYTE $0xff // vpbroadcastq $-608(%rip), %xmm2 /* LCPI4_1(%rip) */ + QUAD $0xfffd9f255979e2c4; BYTE $0xff // vpbroadcastq $-609(%rip), %xmm4 /* LCPI4_2(%rip) */ LONG $0xc2e4f9c5 // vpmulhuw %xmm2, %xmm0, %xmm0 - QUAD $0xffff88255979e2c4; BYTE $0xff // vpbroadcastq $-120(%rip), %xmm4 /* LCPI6_2(%rip) */ LONG $0xc4e4f9c5 // vpmulhuw %xmm4, %xmm0, %xmm0 - QUAD $0xffffff542d6ff9c5 // vmovdqa $-172(%rip), %xmm5 /* LCPI6_3(%rip) */ + QUAD $0xfffffd672d6ff9c5 // vmovdqa $-665(%rip), %xmm5 /* LCPI4_3(%rip) */ LONG $0xf5d5f9c5 // vpmullw %xmm5, %xmm0, %xmm6 LONG $0xf673c9c5; BYTE $0x10 // vpsllq $16, %xmm6, %xmm6 LONG $0xc6f9f9c5 // vpsubw %xmm6, %xmm0, %xmm0 @@ -1450,51 +1212,24 @@ _u64toa_large_sse2: LONG $0xf273e9c5; BYTE $0x10 // vpsllq $16, %xmm2, %xmm2 LONG $0xcaf9f1c5 // vpsubw %xmm2, %xmm1, %xmm1 LONG $0xc167f9c5 // vpackuswb %xmm1, %xmm0, %xmm0 - QUAD $0xffffff0e0dfcf9c5 // vpaddb $-242(%rip), %xmm0, %xmm1 /* LCPI6_4(%rip) */ + QUAD $0xfffffd210dfcf9c5 // vpaddb $-735(%rip), %xmm0, %xmm1 /* LCPI4_4(%rip) */ LONG $0xd2efe9c5 // vpxor %xmm2, %xmm2, %xmm2 LONG $0xc274f9c5 // vpcmpeqb %xmm2, %xmm0, %xmm0 LONG $0xc0d7f9c5 // vpmovmskb %xmm0, %eax - WORD $0xd0f7 // notl %eax LONG $0x0080000d; BYTE $0x00 // orl $32768, %eax - WORD $0xbc0f; BYTE $0xc8 // bsfl %eax, %ecx - LONG $0x000010b8; BYTE $0x00 // movl $16, %eax - WORD $0xc829 // subl %ecx, %eax - LONG $0x04e1c148 // shlq $4, %rcx - LONG $0x76158d48; WORD $0x00e1; BYTE $0x00 // leaq $57718(%rip), %rdx /* _VecShiftShuffles(%rip) */ - LONG $0x0071e2c4; WORD $0x1104 // vpshufb (%rcx,%rdx), %xmm1, %xmm0 + LONG $0xff7fff35; BYTE $0xff // xorl $-32769, %eax + WORD $0xbc0f; BYTE $0xc0 // bsfl %eax, %eax + LONG $0x000010b9; BYTE $0x00 // movl $16, %ecx + WORD $0xc129 // subl %eax, %ecx + LONG $0x04e0c148 // shlq $4, %rax + LONG $0xe6158d48; WORD $0x00db; BYTE $0x00 // leaq $56294(%rip), %rdx /* _VecShiftShuffles(%rip) */ + LONG $0x0071e2c4; WORD $0x1004 // vpshufb (%rax,%rdx), %xmm1, %xmm0 LONG $0x077ffac5 // vmovdqu %xmm0, (%rdi) + WORD $0xc889 // movl %ecx, %eax BYTE $0x5d // popq %rbp BYTE $0xc3 // retq - QUAD $0x0000000000000000; WORD $0x0000 // .p2align 4, 0x00 -LCPI7_0: - QUAD $0x00000000d1b71759 // .quad 3518437209 - QUAD $0x00000000d1b71759 // .quad 3518437209 - -LCPI7_3: - WORD $0x000a // .word 10 - WORD $0x000a // .word 10 - WORD $0x000a // .word 10 - WORD $0x000a // .word 10 - WORD $0x000a // .word 10 - WORD $0x000a // .word 10 - WORD $0x000a // .word 10 - WORD $0x000a // .word 10 - -LCPI7_4: - QUAD $0x3030303030303030; QUAD $0x3030303030303030 // .space 16, '0000000000000000' - - // .p2align 3, 0x00 -LCPI7_1: - QUAD $0x80003334147b20c5 // .quad -9223315738079846203 - -LCPI7_2: - QUAD $0x8000200008000080 // .quad -9223336852348469120 - - // .p2align 4, 0x90 -_u64toa_xlarge_sse2: - BYTE $0x55 // pushq %rbp - WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp +LBB4_18: QUAD $0x652fb1137857b948; WORD $0x39a5 // movabsq $4153837486827862103, %rcx WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax WORD $0xf748; BYTE $0xe1 // mulq %rcx @@ -1503,29 +1238,31 @@ _u64toa_xlarge_sse2: LONG $0xc2af0f48 // imulq %rdx, %rax WORD $0x2948; BYTE $0xc6 // subq %rax, %rsi WORD $0xfa83; BYTE $0x09 // cmpl $9, %edx - LONG $0x000f870f; WORD $0x0000 // ja LBB7_2, $15(%rip) + LONG $0x000f870f; WORD $0x0000 // ja LBB4_20, $15(%rip) WORD $0xc280; BYTE $0x30 // addb $48, %dl WORD $0x1788 // movb %dl, (%rdi) LONG $0x000001b9; BYTE $0x00 // movl $1, %ecx - LONG $0x0000a7e9; BYTE $0x00 // jmp LBB7_7, $167(%rip) + LONG $0x0000bae9; BYTE $0x00 // jmp LBB4_25, $186(%rip) -LBB7_2: +LBB4_20: WORD $0xfa83; BYTE $0x63 // cmpl $99, %edx - LONG $0x001a870f; WORD $0x0000 // ja LBB7_4, $26(%rip) + LONG $0x001f870f; WORD $0x0000 // ja LBB4_22, $31(%rip) WORD $0xd089 // movl %edx, %eax - LONG $0x6d0d8d48; WORD $0x00b9; BYTE $0x00 // leaq $47469(%rip), %rcx /* _Digits(%rip) */ - LONG $0x4104b70f // movzwl (%rcx,%rax,2), %eax - WORD $0x8966; BYTE $0x07 // movw %ax, (%rdi) + LONG $0x290d8d48; WORD $0x00b4; BYTE $0x00 // leaq $46121(%rip), %rcx /* _Digits(%rip) */ + WORD $0x148a; BYTE $0x41 // movb (%rcx,%rax,2), %dl + LONG $0x0141448a // movb $1(%rcx,%rax,2), %al + WORD $0x1788 // movb %dl, (%rdi) + WORD $0x4788; BYTE $0x01 // movb %al, $1(%rdi) LONG $0x000002b9; BYTE $0x00 // movl $2, %ecx - LONG $0x000084e9; BYTE $0x00 // jmp LBB7_7, $132(%rip) + LONG $0x000092e9; BYTE $0x00 // jmp LBB4_25, $146(%rip) -LBB7_4: +LBB4_22: WORD $0xd089 // movl %edx, %eax WORD $0xe8c1; BYTE $0x02 // shrl $2, %eax LONG $0x147bc069; WORD $0x0000 // imull $5243, %eax, %eax WORD $0xe8c1; BYTE $0x11 // shrl $17, %eax LONG $0x03e7fa81; WORD $0x0000 // cmpl $999, %edx - LONG $0x0037870f; WORD $0x0000 // ja LBB7_6, $55(%rip) + LONG $0x003c870f; WORD $0x0000 // ja LBB4_24, $60(%rip) WORD $0xc083; BYTE $0x30 // addl $48, %eax WORD $0x0788 // movb %al, (%rdi) WORD $0xb70f; BYTE $0xc2 // movzwl %dx, %eax @@ -1536,101 +1273,106 @@ LBB7_4: WORD $0xc96b; BYTE $0x64 // imull $100, %ecx, %ecx WORD $0xc829 // subl %ecx, %eax WORD $0xb70f; BYTE $0xc0 // movzwl %ax, %eax - LONG $0x1d0d8d48; WORD $0x00b9; BYTE $0x00 // leaq $47389(%rip), %rcx /* _Digits(%rip) */ - LONG $0x4104b70f // movzwl (%rcx,%rax,2), %eax - LONG $0x01478966 // movw %ax, $1(%rdi) + LONG $0xd40d8d48; WORD $0x00b3; BYTE $0x00 // leaq $46036(%rip), %rcx /* _Digits(%rip) */ + WORD $0x148a; BYTE $0x41 // movb (%rcx,%rax,2), %dl + LONG $0x0141448a // movb $1(%rcx,%rax,2), %al + WORD $0x5788; BYTE $0x01 // movb %dl, $1(%rdi) + WORD $0x4788; BYTE $0x02 // movb %al, $2(%rdi) LONG $0x000003b9; BYTE $0x00 // movl $3, %ecx - LONG $0x000033e9; BYTE $0x00 // jmp LBB7_7, $51(%rip) + LONG $0x00003ce9; BYTE $0x00 // jmp LBB4_25, $60(%rip) -LBB7_6: +LBB4_24: WORD $0xc86b; BYTE $0x64 // imull $100, %eax, %ecx WORD $0xca29 // subl %ecx, %edx WORD $0xb70f; BYTE $0xc0 // movzwl %ax, %eax - LONG $0xfc0d8d48; WORD $0x00b8; BYTE $0x00 // leaq $47356(%rip), %rcx /* _Digits(%rip) */ - LONG $0x4104b70f // movzwl (%rcx,%rax,2), %eax - WORD $0x8966; BYTE $0x07 // movw %ax, (%rdi) + LONG $0xae058d4c; WORD $0x00b3; BYTE $0x00 // leaq $45998(%rip), %r8 /* _Digits(%rip) */ + LONG $0x400c8a41 // movb (%r8,%rax,2), %cl + LONG $0x40448a41; BYTE $0x01 // movb $1(%r8,%rax,2), %al + WORD $0x0f88 // movb %cl, (%rdi) + WORD $0x4788; BYTE $0x01 // movb %al, $1(%rdi) WORD $0xb70f; BYTE $0xc2 // movzwl %dx, %eax - LONG $0x4114b60f // movzbl (%rcx,%rax,2), %edx + LONG $0x400c8a41 // movb (%r8,%rax,2), %cl WORD $0x0148; BYTE $0xc0 // addq %rax, %rax - WORD $0x5788; BYTE $0x02 // movb %dl, $2(%rdi) + WORD $0x4f88; BYTE $0x02 // movb %cl, $2(%rdi) + WORD $0xc883; BYTE $0x01 // orl $1, %eax WORD $0xb70f; BYTE $0xc0 // movzwl %ax, %eax - LONG $0x0844b60f; BYTE $0x01 // movzbl $1(%rax,%rcx), %eax + LONG $0x00048a42 // movb (%rax,%r8), %al WORD $0x4788; BYTE $0x03 // movb %al, $3(%rdi) LONG $0x000004b9; BYTE $0x00 // movl $4, %ecx -LBB7_7: - QUAD $0x77118461cefdba48; WORD $0xabcc // movabsq $-6067343680855748867, %rdx - WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax - WORD $0xf748; BYTE $0xe2 // mulq %rdx - LONG $0x1aeac148 // shrq $26, %rdx - LONG $0xc26ef9c5 // vmovd %edx, %xmm0 - QUAD $0xfffffeb80d6ff9c5 // vmovdqa $-328(%rip), %xmm1 /* LCPI7_0(%rip) */ - LONG $0xd1f4f9c5 // vpmuludq %xmm1, %xmm0, %xmm2 - LONG $0xd273e9c5; BYTE $0x2d // vpsrlq $45, %xmm2, %xmm2 - LONG $0x002710b8; BYTE $0x00 // movl $10000, %eax - LONG $0x6ef9e1c4; BYTE $0xd8 // vmovq %rax, %xmm3 - LONG $0xe3f4e9c5 // vpmuludq %xmm3, %xmm2, %xmm4 - LONG $0xc4faf9c5 // vpsubd %xmm4, %xmm0, %xmm0 - LONG $0xc061e9c5 // vpunpcklwd %xmm0, %xmm2, %xmm0 - LONG $0xf073f9c5; BYTE $0x02 // vpsllq $2, %xmm0, %xmm0 - LONG $0xc070fbc5; BYTE $0x50 // vpshuflw $80, %xmm0, %xmm0 - QUAD $0xfffeb6155979e2c4; BYTE $0xff // vpbroadcastq $-330(%rip), %xmm2 /* LCPI7_1(%rip) */ - LONG $0xc070f9c5; BYTE $0x50 // vpshufd $80, %xmm0, %xmm0 - LONG $0xc2e4f9c5 // vpmulhuw %xmm2, %xmm0, %xmm0 - QUAD $0xfffeac255979e2c4; BYTE $0xff // vpbroadcastq $-340(%rip), %xmm4 /* LCPI7_2(%rip) */ - LONG $0xc4e4f9c5 // vpmulhuw %xmm4, %xmm0, %xmm0 - QUAD $0xfffffe782d6ff9c5 // vmovdqa $-392(%rip), %xmm5 /* LCPI7_3(%rip) */ - LONG $0xf5d5f9c5 // vpmullw %xmm5, %xmm0, %xmm6 - LONG $0xf673c9c5; BYTE $0x10 // vpsllq $16, %xmm6, %xmm6 - LONG $0xc6f9f9c5 // vpsubw %xmm6, %xmm0, %xmm0 - LONG $0xe100c269; WORD $0x05f5 // imull $100000000, %edx, %eax - WORD $0xc629 // subl %eax, %esi - LONG $0xf66ef9c5 // vmovd %esi, %xmm6 - LONG $0xc9f4c9c5 // vpmuludq %xmm1, %xmm6, %xmm1 - LONG $0xd173f1c5; BYTE $0x2d // vpsrlq $45, %xmm1, %xmm1 - LONG $0xdbf4f1c5 // vpmuludq %xmm3, %xmm1, %xmm3 - LONG $0xdbfac9c5 // vpsubd %xmm3, %xmm6, %xmm3 - LONG $0xcb61f1c5 // vpunpcklwd %xmm3, %xmm1, %xmm1 - LONG $0xf173f1c5; BYTE $0x02 // vpsllq $2, %xmm1, %xmm1 - LONG $0xc970fbc5; BYTE $0x50 // vpshuflw $80, %xmm1, %xmm1 - LONG $0xc970f9c5; BYTE $0x50 // vpshufd $80, %xmm1, %xmm1 - LONG $0xcae4f1c5 // vpmulhuw %xmm2, %xmm1, %xmm1 - LONG $0xcce4f1c5 // vpmulhuw %xmm4, %xmm1, %xmm1 - LONG $0xd5d5f1c5 // vpmullw %xmm5, %xmm1, %xmm2 - LONG $0xf273e9c5; BYTE $0x10 // vpsllq $16, %xmm2, %xmm2 - LONG $0xcaf9f1c5 // vpsubw %xmm2, %xmm1, %xmm1 - LONG $0xc167f9c5 // vpackuswb %xmm1, %xmm0, %xmm0 - QUAD $0xfffffe2a05fcf9c5 // vpaddb $-470(%rip), %xmm0, %xmm0 /* LCPI7_4(%rip) */ - WORD $0xc889 // movl %ecx, %eax - LONG $0x047ffac5; BYTE $0x07 // vmovdqu %xmm0, (%rdi,%rax) - WORD $0xc983; BYTE $0x10 // orl $16, %ecx - WORD $0xc889 // movl %ecx, %eax - BYTE $0x5d // popq %rbp - BYTE $0xc3 // retq - QUAD $0x0000000000000000; QUAD $0x0000000000000000; QUAD $0x0000000000000000; LONG $0x00000000 // .p2align 5, 0x00 - -LCPI8_0: +LBB4_25: + QUAD $0x77118461cefdba48; WORD $0xabcc // movabsq $-6067343680855748867, %rdx + WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax + WORD $0xf748; BYTE $0xe2 // mulq %rdx + LONG $0x1aeac148 // shrq $26, %rdx + LONG $0xc26ef9c5 // vmovd %edx, %xmm0 + QUAD $0xfffffbb10d6ff9c5 // vmovdqa $-1103(%rip), %xmm1 /* LCPI4_0(%rip) */ + LONG $0xd1f4f9c5 // vpmuludq %xmm1, %xmm0, %xmm2 + LONG $0xd273e9c5; BYTE $0x2d // vpsrlq $45, %xmm2, %xmm2 + LONG $0x002710b8; BYTE $0x00 // movl $10000, %eax + LONG $0x6ef9e1c4; BYTE $0xd8 // vmovq %rax, %xmm3 + LONG $0xe3f4e9c5 // vpmuludq %xmm3, %xmm2, %xmm4 + LONG $0xc4faf9c5 // vpsubd %xmm4, %xmm0, %xmm0 + LONG $0xc061e9c5 // vpunpcklwd %xmm0, %xmm2, %xmm0 + LONG $0xf073f9c5; BYTE $0x02 // vpsllq $2, %xmm0, %xmm0 + LONG $0xc070fbc5; BYTE $0x50 // vpshuflw $80, %xmm0, %xmm0 + QUAD $0xfffbaf155979e2c4; BYTE $0xff // vpbroadcastq $-1105(%rip), %xmm2 /* LCPI4_1(%rip) */ + LONG $0xc070f9c5; BYTE $0x50 // vpshufd $80, %xmm0, %xmm0 + LONG $0xc2e4f9c5 // vpmulhuw %xmm2, %xmm0, %xmm0 + QUAD $0xfffba5255979e2c4; BYTE $0xff // vpbroadcastq $-1115(%rip), %xmm4 /* LCPI4_2(%rip) */ + LONG $0xc4e4f9c5 // vpmulhuw %xmm4, %xmm0, %xmm0 + QUAD $0xfffffb712d6ff9c5 // vmovdqa $-1167(%rip), %xmm5 /* LCPI4_3(%rip) */ + LONG $0xf5d5f9c5 // vpmullw %xmm5, %xmm0, %xmm6 + LONG $0xf673c9c5; BYTE $0x10 // vpsllq $16, %xmm6, %xmm6 + LONG $0xc6f9f9c5 // vpsubw %xmm6, %xmm0, %xmm0 + LONG $0xe100c269; WORD $0x05f5 // imull $100000000, %edx, %eax + WORD $0xc629 // subl %eax, %esi + LONG $0xf66ef9c5 // vmovd %esi, %xmm6 + LONG $0xc9f4c9c5 // vpmuludq %xmm1, %xmm6, %xmm1 + LONG $0xd173f1c5; BYTE $0x2d // vpsrlq $45, %xmm1, %xmm1 + LONG $0xdbf4f1c5 // vpmuludq %xmm3, %xmm1, %xmm3 + LONG $0xdbfac9c5 // vpsubd %xmm3, %xmm6, %xmm3 + LONG $0xcb61f1c5 // vpunpcklwd %xmm3, %xmm1, %xmm1 + LONG $0xf173f1c5; BYTE $0x02 // vpsllq $2, %xmm1, %xmm1 + LONG $0xc970fbc5; BYTE $0x50 // vpshuflw $80, %xmm1, %xmm1 + LONG $0xc970f9c5; BYTE $0x50 // vpshufd $80, %xmm1, %xmm1 + LONG $0xcae4f1c5 // vpmulhuw %xmm2, %xmm1, %xmm1 + LONG $0xcce4f1c5 // vpmulhuw %xmm4, %xmm1, %xmm1 + LONG $0xd5d5f1c5 // vpmullw %xmm5, %xmm1, %xmm2 + LONG $0xf273e9c5; BYTE $0x10 // vpsllq $16, %xmm2, %xmm2 + LONG $0xcaf9f1c5 // vpsubw %xmm2, %xmm1, %xmm1 + LONG $0xc167f9c5 // vpackuswb %xmm1, %xmm0, %xmm0 + QUAD $0xfffffb2305fcf9c5 // vpaddb $-1245(%rip), %xmm0, %xmm0 /* LCPI4_4(%rip) */ + WORD $0xc889 // movl %ecx, %eax + LONG $0x047ffac5; BYTE $0x07 // vmovdqu %xmm0, (%rdi,%rax) + WORD $0xc983; BYTE $0x10 // orl $16, %ecx + WORD $0xc889 // movl %ecx, %eax + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + LONG $0x00000000; BYTE $0x00 // .p2align 5, 0x00 + +LCPI5_0: + QUAD $0x2020202020202020; QUAD $0x2020202020202020 // .space 16, ' ' + QUAD $0x2020202020202020; QUAD $0x2020202020202020 // .space 16, ' ' + +LCPI5_1: QUAD $0x2222222222222222; QUAD $0x2222222222222222 // .space 16, '""""""""""""""""' QUAD $0x2222222222222222; QUAD $0x2222222222222222 // .space 16, '""""""""""""""""' -LCPI8_1: +LCPI5_2: QUAD $0x5c5c5c5c5c5c5c5c; QUAD $0x5c5c5c5c5c5c5c5c // .space 16, '\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' QUAD $0x5c5c5c5c5c5c5c5c; QUAD $0x5c5c5c5c5c5c5c5c // .space 16, '\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' -LCPI8_2: - QUAD $0x1f1f1f1f1f1f1f1f; QUAD $0x1f1f1f1f1f1f1f1f // .space 16, '\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f' - QUAD $0x1f1f1f1f1f1f1f1f; QUAD $0x1f1f1f1f1f1f1f1f // .space 16, '\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f' - // .p2align 4, 0x00 -LCPI8_3: +LCPI5_3: + QUAD $0x2020202020202020; QUAD $0x2020202020202020 // .space 16, ' ' + +LCPI5_4: QUAD $0x2222222222222222; QUAD $0x2222222222222222 // .space 16, '""""""""""""""""' -LCPI8_4: +LCPI5_5: QUAD $0x5c5c5c5c5c5c5c5c; QUAD $0x5c5c5c5c5c5c5c5c // .space 16, '\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' -LCPI8_5: - QUAD $0x1f1f1f1f1f1f1f1f; QUAD $0x1f1f1f1f1f1f1f1f // .space 16, '\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f' - // .p2align 4, 0x90 _quote: BYTE $0x55 // pushq %rbp @@ -1640,725 +1382,748 @@ _quote: WORD $0x5541 // pushq %r13 WORD $0x5441 // pushq %r12 BYTE $0x53 // pushq %rbx - LONG $0x18ec8348 // subq $24, %rsp + BYTE $0x50 // pushq %rax WORD $0x8949; BYTE $0xcf // movq %rcx, %r15 - WORD $0x8949; BYTE $0xf6 // movq %rsi, %r14 - WORD $0x8b4c; BYTE $0x11 // movq (%rcx), %r10 + WORD $0x8949; BYTE $0xf2 // movq %rsi, %r10 + WORD $0x8b4c; BYTE $0x09 // movq (%rcx), %r9 LONG $0x01c0f641 // testb $1, %r8b - LONG $0x1b058d48; WORD $0x00df; BYTE $0x00 // leaq $57115(%rip), %rax /* __SingleQuoteTab(%rip) */ - LONG $0x14058d4c; WORD $0x00ef; BYTE $0x00 // leaq $61204(%rip), %r8 /* __DoubleQuoteTab(%rip) */ + LONG $0xde058d48; WORD $0x00d9; BYTE $0x00 // leaq $55774(%rip), %rax /* __SingleQuoteTab(%rip) */ + LONG $0xd7058d4c; WORD $0x00e9; BYTE $0x00 // leaq $59863(%rip), %r8 /* __DoubleQuoteTab(%rip) */ LONG $0xc0440f4c // cmoveq %rax, %r8 QUAD $0x00000000f5048d48 // leaq (,%rsi,8), %rax - WORD $0x3949; BYTE $0xc2 // cmpq %rax, %r10 - LONG $0x07128d0f; WORD $0x0000 // jge LBB8_93, $1810(%rip) - WORD $0x8949; BYTE $0xd1 // movq %rdx, %r9 + WORD $0x3949; BYTE $0xc1 // cmpq %rax, %r9 + LONG $0x06e78d0f; WORD $0x0000 // jge LBB5_88, $1767(%rip) + WORD $0x8949; BYTE $0xd4 // movq %rdx, %r12 WORD $0x8949; BYTE $0xfb // movq %rdi, %r11 - WORD $0x854d; BYTE $0xf6 // testq %r14, %r14 - LONG $0x09ef840f; WORD $0x0000 // je LBB8_122, $2543(%rip) - QUAD $0xffffff181d6ffdc5 // vmovdqa $-232(%rip), %ymm3 /* LCPI8_0(%rip) */ - QUAD $0xffffff30256ffdc5 // vmovdqa $-208(%rip), %ymm4 /* LCPI8_1(%rip) */ - QUAD $0xffffff482d6ffdc5 // vmovdqa $-184(%rip), %ymm5 /* LCPI8_2(%rip) */ - WORD $0x8948; BYTE $0xf9 // movq %rdi, %rcx - LONG $0xc0558948 // movq %rdx, $-64(%rbp) - WORD $0x8949; BYTE $0xd1 // movq %rdx, %r9 - -LBB8_3: - WORD $0x8949; BYTE $0xcd // movq %rcx, %r13 - LONG $0x20fe8349 // cmpq $32, %r14 - WORD $0x9d0f; BYTE $0xc1 // setge %cl - LONG $0x20fa8349 // cmpq $32, %r10 - WORD $0x894c; BYTE $0xe8 // movq %r13, %rax - WORD $0x894c; BYTE $0xd3 // movq %r10, %rbx - WORD $0x894d; BYTE $0xcc // movq %r9, %r12 - WORD $0x894d; BYTE $0xf3 // movq %r14, %r11 - LONG $0x007e8c0f; WORD $0x0000 // jl LBB8_10, $126(%rip) - LONG $0x20fe8349 // cmpq $32, %r14 - LONG $0x00748c0f; WORD $0x0000 // jl LBB8_10, $116(%rip) - WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d - WORD $0x894c; BYTE $0xf6 // movq %r14, %rsi - WORD $0x894c; BYTE $0xd2 // movq %r10, %rdx - QUAD $0x9090909090909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + WORD $0x854d; BYTE $0xd2 // testq %r10, %r10 + LONG $0x0a22840f; WORD $0x0000 // je LBB5_120, $2594(%rip) + QUAD $0xffffff1b256ffdc5 // vmovdqa $-229(%rip), %ymm4 /* LCPI5_0(%rip) */ + QUAD $0xffffff332d6ffdc5 // vmovdqa $-205(%rip), %ymm5 /* LCPI5_1(%rip) */ + QUAD $0xffffff4b356ffdc5 // vmovdqa $-181(%rip), %ymm6 /* LCPI5_2(%rip) */ + LONG $0x763d41c4; BYTE $0xc0 // vpcmpeqd %ymm8, %ymm8, %ymm8 + WORD $0x8949; BYTE $0xfb // movq %rdi, %r11 + WORD $0x8949; BYTE $0xd4 // movq %rdx, %r12 + LONG $0xd0558948 // movq %rdx, $-48(%rbp) -LBB8_6: - LONG $0x6f7ea1c4; WORD $0x2004 // vmovdqu (%rax,%r12), %ymm0 - LONG $0xcb74fdc5 // vpcmpeqb %ymm3, %ymm0, %ymm1 - LONG $0xd474fdc5 // vpcmpeqb %ymm4, %ymm0, %ymm2 - LONG $0xc9ebedc5 // vpor %ymm1, %ymm2, %ymm1 - LONG $0x7f7e81c4; WORD $0x2104 // vmovdqu %ymm0, (%r9,%r12) - LONG $0xd5dafdc5 // vpminub %ymm5, %ymm0, %ymm2 - LONG $0xc274fdc5 // vpcmpeqb %ymm2, %ymm0, %ymm0 - LONG $0xc0ebf5c5 // vpor %ymm0, %ymm1, %ymm0 - LONG $0xc8d7fdc5 // vpmovmskb %ymm0, %ecx - WORD $0xc985 // testl %ecx, %ecx - LONG $0x01d8850f; WORD $0x0000 // jne LBB8_20, $472(%rip) - LONG $0xe05e8d4c // leaq $-32(%rsi), %r11 - LONG $0xe05a8d48 // leaq $-32(%rdx), %rbx - LONG $0x20c48349 // addq $32, %r12 - LONG $0x40fe8348 // cmpq $64, %rsi - WORD $0x9d0f; BYTE $0xc1 // setge %cl - LONG $0x00108c0f; WORD $0x0000 // jl LBB8_9, $16(%rip) - WORD $0x894c; BYTE $0xde // movq %r11, %rsi - LONG $0x3ffa8348 // cmpq $63, %rdx - WORD $0x8948; BYTE $0xda // movq %rbx, %rdx - LONG $0xffa78f0f; WORD $0xffff // jg LBB8_6, $-89(%rip) +LBB5_3: + WORD $0x894c; BYTE $0xfa // movq %r15, %rdx + LONG $0x1ffa8349 // cmpq $31, %r10 + WORD $0x9f0f; BYTE $0xc1 // setg %cl + WORD $0x894d; BYTE $0xce // movq %r9, %r14 + WORD $0x894c; BYTE $0xe6 // movq %r12, %rsi + WORD $0x894d; BYTE $0xd7 // movq %r10, %r15 + WORD $0x894d; BYTE $0xdd // movq %r11, %r13 + LONG $0x20f98349 // cmpq $32, %r9 + LONG $0x008c8c0f; WORD $0x0000 // jl LBB5_9, $140(%rip) + LONG $0x20fa8349 // cmpq $32, %r10 + LONG $0x00828c0f; WORD $0x0000 // jl LBB5_9, $130(%rip) + WORD $0x894d; BYTE $0xdd // movq %r11, %r13 + WORD $0x894c; BYTE $0xd0 // movq %r10, %rax + WORD $0x894c; BYTE $0xe6 // movq %r12, %rsi + WORD $0x894c; BYTE $0xcb // movq %r9, %rbx + LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 -LBB8_9: - LONG $0x202c8d4e // leaq (%rax,%r12), %r13 - WORD $0x014d; BYTE $0xcc // addq %r9, %r12 +LBB5_6: + LONG $0x6f7ec1c4; WORD $0x0045 // vmovdqu (%r13), %ymm0 + LONG $0xc864ddc5 // vpcmpgtb %ymm0, %ymm4, %ymm1 + LONG $0xd574fdc5 // vpcmpeqb %ymm5, %ymm0, %ymm2 + LONG $0xde74fdc5 // vpcmpeqb %ymm6, %ymm0, %ymm3 + LONG $0xd2ebe5c5 // vpor %ymm2, %ymm3, %ymm2 + LONG $0x067ffec5 // vmovdqu %ymm0, (%rsi) + LONG $0x647dc1c4; BYTE $0xc0 // vpcmpgtb %ymm8, %ymm0, %ymm0 + LONG $0xc0dbf5c5 // vpand %ymm0, %ymm1, %ymm0 + LONG $0xc0ebedc5 // vpor %ymm0, %ymm2, %ymm0 + LONG $0xc8d7fdc5 // vpmovmskb %ymm0, %ecx + WORD $0xc985 // testl %ecx, %ecx + LONG $0x01f8850f; WORD $0x0000 // jne LBB5_19, $504(%rip) + LONG $0x20c58349 // addq $32, %r13 + LONG $0x20c68348 // addq $32, %rsi + LONG $0xe0788d4c // leaq $-32(%rax), %r15 + LONG $0xe0738d4c // leaq $-32(%rbx), %r14 + LONG $0x3ff88348 // cmpq $63, %rax + WORD $0x9f0f; BYTE $0xc1 // setg %cl + LONG $0x40f88348 // cmpq $64, %rax + LONG $0x001c8c0f; WORD $0x0000 // jl LBB5_9, $28(%rip) + WORD $0x894c; BYTE $0xf8 // movq %r15, %rax + LONG $0x3ffb8348 // cmpq $63, %rbx + WORD $0x894c; BYTE $0xf3 // movq %r14, %rbx + LONG $0xff9c8f0f; WORD $0xffff // jg LBB5_6, $-100(%rip) + QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90 -LBB8_10: +LBB5_9: WORD $0xc984 // testb %cl, %cl - LONG $0x007b840f; WORD $0x0000 // je LBB8_14, $123(%rip) - WORD $0x894c; BYTE $0xf6 // movq %r14, %rsi + LONG $0x0081840f; WORD $0x0000 // je LBB5_13, $129(%rip) LONG $0x6f7ec1c4; WORD $0x0045 // vmovdqu (%r13), %ymm0 - LONG $0xcb74fdc5 // vpcmpeqb %ymm3, %ymm0, %ymm1 - LONG $0xd474fdc5 // vpcmpeqb %ymm4, %ymm0, %ymm2 - LONG $0xc9ebedc5 // vpor %ymm1, %ymm2, %ymm1 - LONG $0xd5dafdc5 // vpminub %ymm5, %ymm0, %ymm2 - LONG $0xc274fdc5 // vpcmpeqb %ymm2, %ymm0, %ymm0 - LONG $0xc0ebf5c5 // vpor %ymm0, %ymm1, %ymm0 - LONG $0xc8d7fdc5 // vpmovmskb %ymm0, %ecx - QUAD $0x000100000000ba48; WORD $0x0000 // movabsq $4294967296, %rdx - WORD $0x0948; BYTE $0xd1 // orq %rdx, %rcx - LONG $0xf1bc0f4c // bsfq %rcx, %r14 - LONG $0x00558b49 // movq (%r13), %rdx - LONG $0x084d8b49 // movq $8(%r13), %rcx - WORD $0x3949; BYTE $0xde // cmpq %rbx, %r14 - LONG $0x01688e0f; WORD $0x0000 // jle LBB8_21, $360(%rip) - LONG $0x10fb8348 // cmpq $16, %rbx - WORD $0x8949; BYTE $0xc3 // movq %rax, %r11 - LONG $0x01a7820f; WORD $0x0000 // jb LBB8_24, $423(%rip) - LONG $0x24148949 // movq %rdx, (%r12) - LONG $0x244c8949; BYTE $0x08 // movq %rcx, $8(%r12) - LONG $0x104d8d49 // leaq $16(%r13), %rcx - LONG $0x10c48349 // addq $16, %r12 - LONG $0xf0538d48 // leaq $-16(%rbx), %rdx - WORD $0x8949; BYTE $0xf6 // movq %rsi, %r14 - LONG $0x08fa8348 // cmpq $8, %rdx - LONG $0x0198830f; WORD $0x0000 // jae LBB8_25, $408(%rip) - LONG $0x0001a6e9; BYTE $0x00 // jmp LBB8_26, $422(%rip) - -LBB8_14: - WORD $0xf8c5; BYTE $0x77 // vzeroupper - LONG $0x10fb8349 // cmpq $16, %r11 - WORD $0x9d0f; BYTE $0xc2 // setge %dl - LONG $0xc87d894c // movq %r15, $-56(%rbp) - LONG $0xd075894c // movq %r14, $-48(%rbp) - LONG $0x02018c0f; WORD $0x0000 // jl LBB8_31, $513(%rip) - LONG $0x10fb8348 // cmpq $16, %rbx - QUAD $0xfffffe19356ff9c5 // vmovdqa $-487(%rip), %xmm6 /* LCPI8_3(%rip) */ - QUAD $0xfffffe213d6ff9c5 // vmovdqa $-479(%rip), %xmm7 /* LCPI8_4(%rip) */ - QUAD $0xfffffe29056f79c5 // vmovdqa $-471(%rip), %xmm8 /* LCPI8_5(%rip) */ - LONG $0x02228c0f; WORD $0x0000 // jl LBB8_36, $546(%rip) - WORD $0x8948; BYTE $0xc1 // movq %rax, %rcx - WORD $0x294c; BYTE $0xe9 // subq %r13, %rcx - QUAD $0xfffffd951d6ffdc5 // vmovdqa $-619(%rip), %ymm3 /* LCPI8_0(%rip) */ - QUAD $0xfffffdad256ffdc5 // vmovdqa $-595(%rip), %ymm4 /* LCPI8_1(%rip) */ - QUAD $0xfffffdc52d6ffdc5 // vmovdqa $-571(%rip), %ymm5 /* LCPI8_2(%rip) */ - LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 + LONG $0xc864ddc5 // vpcmpgtb %ymm0, %ymm4, %ymm1 + LONG $0xd574fdc5 // vpcmpeqb %ymm5, %ymm0, %ymm2 + LONG $0xde74fdc5 // vpcmpeqb %ymm6, %ymm0, %ymm3 + LONG $0xd2ebe5c5 // vpor %ymm2, %ymm3, %ymm2 + LONG $0x647dc1c4; BYTE $0xc0 // vpcmpgtb %ymm8, %ymm0, %ymm0 + LONG $0xc0dbf5c5 // vpand %ymm0, %ymm1, %ymm0 + LONG $0xc0ebedc5 // vpor %ymm0, %ymm2, %ymm0 + LONG $0xc0d7fdc5 // vpmovmskb %ymm0, %eax + QUAD $0x000100000000b948; WORD $0x0000 // movabsq $4294967296, %rcx + WORD $0x0948; BYTE $0xc8 // orq %rcx, %rax + LONG $0xc8bc0f48 // bsfq %rax, %rcx + LONG $0x6f7ac1c4; WORD $0x0045 // vmovdqu (%r13), %xmm0 + LONG $0x16f9e3c4; WORD $0x01c0 // vpextrq $1, %xmm0, %rax + LONG $0x7ef9e1c4; BYTE $0xc3 // vmovq %xmm0, %rbx + WORD $0x394c; BYTE $0xf1 // cmpq %r14, %rcx + LONG $0x016d8e0f; WORD $0x0000 // jle LBB5_20, $365(%rip) + LONG $0x10fe8349 // cmpq $16, %r14 + WORD $0x8949; BYTE $0xd7 // movq %rdx, %r15 + LONG $0x01a3820f; WORD $0x0000 // jb LBB5_24, $419(%rip) + WORD $0x8948; BYTE $0x1e // movq %rbx, (%rsi) + LONG $0x08468948 // movq %rax, $8(%rsi) + LONG $0x10458d49 // leaq $16(%r13), %rax + LONG $0x10c68348 // addq $16, %rsi + LONG $0xf04e8d49 // leaq $-16(%r14), %rcx + LONG $0x08f98348 // cmpq $8, %rcx + LONG $0x0196830f; WORD $0x0000 // jae LBB5_25, $406(%rip) + LONG $0x0001a3e9; BYTE $0x00 // jmp LBB5_26, $419(%rip) + +LBB5_13: + WORD $0xf8c5; BYTE $0x77 // vzeroupper + LONG $0x0fff8349 // cmpq $15, %r15 + WORD $0x9f0f; BYTE $0xc1 // setg %cl + LONG $0x10fe8349 // cmpq $16, %r14 + LONG $0x01f88c0f; WORD $0x0000 // jl LBB5_31, $504(%rip) + LONG $0x10ff8349 // cmpq $16, %r15 + QUAD $0xfffffe073d6ff9c5 // vmovdqa $-505(%rip), %xmm7 /* LCPI5_3(%rip) */ + QUAD $0xfffffe0f0d6f79c5 // vmovdqa $-497(%rip), %xmm9 /* LCPI5_4(%rip) */ + QUAD $0xfffffe17156f79c5 // vmovdqa $-489(%rip), %xmm10 /* LCPI5_5(%rip) */ + LONG $0x762141c4; BYTE $0xdb // vpcmpeqd %xmm11, %xmm11, %xmm11 + LONG $0x021e8c0f; WORD $0x0000 // jl LBB5_36, $542(%rip) + QUAD $0xfffffd84256ffdc5 // vmovdqa $-636(%rip), %ymm4 /* LCPI5_0(%rip) */ + QUAD $0xfffffd9c2d6ffdc5 // vmovdqa $-612(%rip), %ymm5 /* LCPI5_1(%rip) */ + QUAD $0xfffffdb4356ffdc5 // vmovdqa $-588(%rip), %ymm6 /* LCPI5_2(%rip) */ + LONG $0x763d41c4; BYTE $0xc0 // vpcmpeqd %ymm8, %ymm8, %ymm8 + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 -LBB8_17: +LBB5_16: LONG $0x6f7ac1c4; WORD $0x0045 // vmovdqu (%r13), %xmm0 - LONG $0xce74f9c5 // vpcmpeqb %xmm6, %xmm0, %xmm1 - LONG $0xd774f9c5 // vpcmpeqb %xmm7, %xmm0, %xmm2 - LONG $0xc9ebe9c5 // vpor %xmm1, %xmm2, %xmm1 - LONG $0x7f7ac1c4; WORD $0x2404 // vmovdqu %xmm0, (%r12) - LONG $0xd0dab9c5 // vpminub %xmm0, %xmm8, %xmm2 - LONG $0xc274f9c5 // vpcmpeqb %xmm2, %xmm0, %xmm0 - LONG $0xc0ebf1c5 // vpor %xmm0, %xmm1, %xmm0 - LONG $0xd0d7f9c5 // vpmovmskb %xmm0, %edx - WORD $0xd285 // testl %edx, %edx - LONG $0x00d8850f; WORD $0x0000 // jne LBB8_23, $216(%rip) + LONG $0xc864c1c5 // vpcmpgtb %xmm0, %xmm7, %xmm1 + LONG $0xd074b1c5 // vpcmpeqb %xmm0, %xmm9, %xmm2 + LONG $0xd874a9c5 // vpcmpeqb %xmm0, %xmm10, %xmm3 + LONG $0xd2ebe1c5 // vpor %xmm2, %xmm3, %xmm2 + LONG $0x067ffac5 // vmovdqu %xmm0, (%rsi) + LONG $0x6479c1c4; BYTE $0xc3 // vpcmpgtb %xmm11, %xmm0, %xmm0 + LONG $0xc0dbf1c5 // vpand %xmm0, %xmm1, %xmm0 + LONG $0xc0ebe9c5 // vpor %xmm0, %xmm2, %xmm0 + LONG $0xc0d7f9c5 // vpmovmskb %xmm0, %eax + WORD $0x8566; BYTE $0xc0 // testw %ax, %ax + LONG $0x00d1850f; WORD $0x0000 // jne LBB5_22, $209(%rip) LONG $0x10c58349 // addq $16, %r13 - LONG $0x10c48349 // addq $16, %r12 - LONG $0xf07b8d4d // leaq $-16(%r11), %r15 - LONG $0xf0738d4c // leaq $-16(%rbx), %r14 - LONG $0x20fb8349 // cmpq $32, %r11 - WORD $0x9d0f; BYTE $0xc2 // setge %dl - LONG $0x00148c0f; WORD $0x0000 // jl LBB8_32, $20(%rip) - LONG $0xf0c18348 // addq $-16, %rcx - WORD $0x894d; BYTE $0xfb // movq %r15, %r11 - LONG $0x1ffb8348 // cmpq $31, %rbx - WORD $0x894c; BYTE $0xf3 // movq %r14, %rbx - LONG $0xff9f8f0f; WORD $0xffff // jg LBB8_17, $-97(%rip) + LONG $0x10c68348 // addq $16, %rsi + LONG $0xf0478d49 // leaq $-16(%r15), %rax + LONG $0xf05e8d49 // leaq $-16(%r14), %rbx + LONG $0x1fff8349 // cmpq $31, %r15 + WORD $0x9f0f; BYTE $0xc1 // setg %cl + LONG $0x20ff8349 // cmpq $32, %r15 + LONG $0x00108c0f; WORD $0x0000 // jl LBB5_32, $16(%rip) + WORD $0x8949; BYTE $0xc7 // movq %rax, %r15 + LONG $0x1ffe8349 // cmpq $31, %r14 + WORD $0x8949; BYTE $0xde // movq %rbx, %r14 + LONG $0xff9b8f0f; WORD $0xffff // jg LBB5_16, $-101(%rip) -LBB8_32: - WORD $0xd284 // testb %dl, %dl - LONG $0x01bc840f; WORD $0x0000 // je LBB8_37, $444(%rip) +LBB5_32: + WORD $0xc984 // testb %cl, %cl + LONG $0x01b0840f; WORD $0x0000 // je LBB5_37, $432(%rip) -LBB8_33: +LBB5_33: LONG $0x6f7ac1c4; WORD $0x0045 // vmovdqu (%r13), %xmm0 - LONG $0xce74f9c5 // vpcmpeqb %xmm6, %xmm0, %xmm1 - LONG $0xd774f9c5 // vpcmpeqb %xmm7, %xmm0, %xmm2 + LONG $0xc864c1c5 // vpcmpgtb %xmm0, %xmm7, %xmm1 + LONG $0xd074b1c5 // vpcmpeqb %xmm0, %xmm9, %xmm2 + LONG $0xd874a9c5 // vpcmpeqb %xmm0, %xmm10, %xmm3 + LONG $0xd2ebe1c5 // vpor %xmm2, %xmm3, %xmm2 + LONG $0x6479c1c4; BYTE $0xdb // vpcmpgtb %xmm11, %xmm0, %xmm3 + LONG $0xcbdbf1c5 // vpand %xmm3, %xmm1, %xmm1 LONG $0xc9ebe9c5 // vpor %xmm1, %xmm2, %xmm1 - LONG $0xd0dab9c5 // vpminub %xmm0, %xmm8, %xmm2 - LONG $0xd274f9c5 // vpcmpeqb %xmm2, %xmm0, %xmm2 - LONG $0xcaebf1c5 // vpor %xmm2, %xmm1, %xmm1 - LONG $0xc9d7f9c5 // vpmovmskb %xmm1, %ecx - LONG $0x0000c981; WORD $0x0001 // orl $65536, %ecx - WORD $0xbc0f; BYTE $0xd9 // bsfl %ecx, %ebx + LONG $0xc1d7f9c5 // vpmovmskb %xmm1, %eax + LONG $0x0100000d; BYTE $0x00 // orl $65536, %eax + WORD $0xbc0f; BYTE $0xc0 // bsfl %eax, %eax LONG $0x7ef9e1c4; BYTE $0xc1 // vmovq %xmm0, %rcx - WORD $0x3949; BYTE $0xde // cmpq %rbx, %r14 - WORD $0x8949; BYTE $0xc3 // movq %rax, %r11 - LONG $0x029e8d0f; WORD $0x0000 // jge LBB8_57, $670(%rip) - LONG $0x08fe8349 // cmpq $8, %r14 - LONG $0xc87d8b4c // movq $-56(%rbp), %r15 - LONG $0x02cd820f; WORD $0x0000 // jb LBB8_62, $717(%rip) - LONG $0x240c8949 // movq %rcx, (%r12) - LONG $0x084d8d49 // leaq $8(%r13), %rcx - LONG $0x08c48349 // addq $8, %r12 - LONG $0xf8568d49 // leaq $-8(%r14), %rdx - LONG $0x0002bee9; BYTE $0x00 // jmp LBB8_63, $702(%rip) - -LBB8_20: - WORD $0x8949; BYTE $0xc3 // movq %rax, %r11 - LONG $0xe9bc0f44 // bsfl %ecx, %r13d - WORD $0x014d; BYTE $0xe5 // addq %r12, %r13 - LONG $0x000379e9; BYTE $0x00 // jmp LBB8_75, $889(%rip) - -LBB8_21: - LONG $0x10fe8341 // cmpl $16, %r14d - WORD $0x8949; BYTE $0xc3 // movq %rax, %r11 - LONG $0x01cc820f; WORD $0x0000 // jb LBB8_46, $460(%rip) - LONG $0x24148949 // movq %rdx, (%r12) - LONG $0x244c8949; BYTE $0x08 // movq %rcx, $8(%r12) - LONG $0x105d8d49 // leaq $16(%r13), %rbx - LONG $0x10c48349 // addq $16, %r12 - LONG $0xf04e8d49 // leaq $-16(%r14), %rcx - LONG $0x08f98348 // cmpq $8, %rcx - LONG $0x01bd830f; WORD $0x0000 // jae LBB8_47, $445(%rip) - LONG $0x0001cbe9; BYTE $0x00 // jmp LBB8_48, $459(%rip) - -LBB8_23: - LONG $0xd2bc0f66 // bsfw %dx, %dx - LONG $0xeab70f44 // movzwl %dx, %r13d - WORD $0x2949; BYTE $0xcd // subq %rcx, %r13 - LONG $0xc87d8b4c // movq $-56(%rbp), %r15 - LONG $0xd0758b4c // movq $-48(%rbp), %r14 - WORD $0x8949; BYTE $0xc3 // movq %rax, %r11 - LONG $0x00032de9; BYTE $0x00 // jmp LBB8_75, $813(%rip) - -LBB8_24: - WORD $0x894c; BYTE $0xe9 // movq %r13, %rcx - WORD $0x8948; BYTE $0xda // movq %rbx, %rdx - WORD $0x8949; BYTE $0xf6 // movq %rsi, %r14 - LONG $0x08fa8348 // cmpq $8, %rdx - LONG $0x0013820f; WORD $0x0000 // jb LBB8_26, $19(%rip) - -LBB8_25: - WORD $0x8b48; BYTE $0x31 // movq (%rcx), %rsi - LONG $0x24348949 // movq %rsi, (%r12) - LONG $0x08c18348 // addq $8, %rcx - LONG $0x08c48349 // addq $8, %r12 - LONG $0xf8c28348 // addq $-8, %rdx - -LBB8_26: - LONG $0x04fa8348 // cmpq $4, %rdx - LONG $0x003d8c0f; WORD $0x0000 // jl LBB8_27, $61(%rip) - WORD $0x318b // movl (%rcx), %esi - LONG $0x24348941 // movl %esi, (%r12) - LONG $0x04c18348 // addq $4, %rcx - LONG $0x04c48349 // addq $4, %r12 - LONG $0xfcc28348 // addq $-4, %rdx - LONG $0x02fa8348 // cmpq $2, %rdx - LONG $0x002b830f; WORD $0x0000 // jae LBB8_54, $43(%rip) - -LBB8_28: - WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx - LONG $0x0007840f; WORD $0x0000 // je LBB8_30, $7(%rip) - -LBB8_29: - WORD $0xb60f; BYTE $0x09 // movzbl (%rcx), %ecx - LONG $0x240c8841 // movb %cl, (%r12) - -LBB8_30: - WORD $0x014c; BYTE $0xeb // addq %r13, %rbx - WORD $0xf748; BYTE $0xd3 // notq %rbx - WORD $0x014c; BYTE $0xdb // addq %r11, %rbx - WORD $0x8949; BYTE $0xdd // movq %rbx, %r13 - LONG $0x0002c0e9; BYTE $0x00 // jmp LBB8_75, $704(%rip) - -LBB8_27: - LONG $0x02fa8348 // cmpq $2, %rdx - LONG $0xffd5820f; WORD $0xffff // jb LBB8_28, $-43(%rip) + WORD $0x3948; BYTE $0xc3 // cmpq %rax, %rbx + WORD $0x8949; BYTE $0xd7 // movq %rdx, %r15 + LONG $0x02618d0f; WORD $0x0000 // jge LBB5_53, $609(%rip) + LONG $0x08fb8348 // cmpq $8, %rbx + LONG $0x027c820f; WORD $0x0000 // jb LBB5_56, $636(%rip) + WORD $0x8948; BYTE $0x0e // movq %rcx, (%rsi) + LONG $0x08458d49 // leaq $8(%r13), %rax + LONG $0x08c68348 // addq $8, %rsi + LONG $0xf84b8d48 // leaq $-8(%rbx), %rcx + LONG $0x00026ee9; BYTE $0x00 // jmp LBB5_57, $622(%rip) -LBB8_54: - WORD $0xb70f; BYTE $0x31 // movzwl (%rcx), %esi - LONG $0x34894166; BYTE $0x24 // movw %si, (%r12) - LONG $0x02c18348 // addq $2, %rcx - LONG $0x02c48349 // addq $2, %r12 - LONG $0xfec28348 // addq $-2, %rdx - WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx - LONG $0xffc1850f; WORD $0xffff // jne LBB8_29, $-63(%rip) - LONG $0xffffc3e9; BYTE $0xff // jmp LBB8_30, $-61(%rip) +LBB5_19: + WORD $0x294d; BYTE $0xdd // subq %r11, %r13 + LONG $0xf1bc0f44 // bsfl %ecx, %r14d + LONG $0x000038e9; BYTE $0x00 // jmp LBB5_23, $56(%rip) -LBB8_31: - WORD $0x8949; BYTE $0xde // movq %rbx, %r14 - WORD $0x894d; BYTE $0xdf // movq %r11, %r15 - QUAD $0xfffffbb61d6ffdc5 // vmovdqa $-1098(%rip), %ymm3 /* LCPI8_0(%rip) */ - QUAD $0xfffffbce256ffdc5 // vmovdqa $-1074(%rip), %ymm4 /* LCPI8_1(%rip) */ - QUAD $0xfffffbe62d6ffdc5 // vmovdqa $-1050(%rip), %ymm5 /* LCPI8_2(%rip) */ - QUAD $0xfffffbfe356ff9c5 // vmovdqa $-1026(%rip), %xmm6 /* LCPI8_3(%rip) */ - QUAD $0xfffffc063d6ff9c5 // vmovdqa $-1018(%rip), %xmm7 /* LCPI8_4(%rip) */ - QUAD $0xfffffc0e056f79c5 // vmovdqa $-1010(%rip), %xmm8 /* LCPI8_5(%rip) */ - WORD $0xd284 // testb %dl, %dl - LONG $0x002b840f; WORD $0x0000 // je LBB8_37, $43(%rip) - LONG $0xfffe6ae9; BYTE $0xff // jmp LBB8_33, $-406(%rip) - -LBB8_36: - WORD $0x8949; BYTE $0xde // movq %rbx, %r14 - WORD $0x894d; BYTE $0xdf // movq %r11, %r15 - QUAD $0xfffffb731d6ffdc5 // vmovdqa $-1165(%rip), %ymm3 /* LCPI8_0(%rip) */ - QUAD $0xfffffb8b256ffdc5 // vmovdqa $-1141(%rip), %ymm4 /* LCPI8_1(%rip) */ - QUAD $0xfffffba32d6ffdc5 // vmovdqa $-1117(%rip), %ymm5 /* LCPI8_2(%rip) */ - WORD $0xd284 // testb %dl, %dl - LONG $0xfe44850f; WORD $0xffff // jne LBB8_33, $-444(%rip) - -LBB8_37: - WORD $0x854d; BYTE $0xff // testq %r15, %r15 - WORD $0x8949; BYTE $0xc3 // movq %rax, %r11 - LONG $0x005d8e0f; WORD $0x0000 // jle LBB8_44, $93(%rip) - WORD $0x854d; BYTE $0xf6 // testq %r14, %r14 - LONG $0x00548e0f; WORD $0x0000 // jle LBB8_44, $84(%rip) - WORD $0xd231 // xorl %edx, %edx - WORD $0xc931 // xorl %ecx, %ecx - WORD $0x9090 // .p2align 4, 0x90 +LBB5_20: + WORD $0xf983; BYTE $0x10 // cmpl $16, %ecx + WORD $0x8949; BYTE $0xd7 // movq %rdx, %r15 + LONG $0x01a3820f; WORD $0x0000 // jb LBB5_42, $419(%rip) + WORD $0x8948; BYTE $0x1e // movq %rbx, (%rsi) + LONG $0x08468948 // movq %rax, $8(%rsi) + LONG $0x10458d49 // leaq $16(%r13), %rax + LONG $0x10c68348 // addq $16, %rsi + LONG $0xf0598d48 // leaq $-16(%rcx), %rbx + LONG $0x08fb8348 // cmpq $8, %rbx + LONG $0x0196830f; WORD $0x0000 // jae LBB5_43, $406(%rip) + LONG $0x0001a3e9; BYTE $0x00 // jmp LBB5_44, $419(%rip) -LBB8_40: - LONG $0x5cb60f41; WORD $0x0015 // movzbl (%r13,%rdx), %ebx - WORD $0x8948; BYTE $0xde // movq %rbx, %rsi - LONG $0x04e6c148 // shlq $4, %rsi - LONG $0xfc058d48; WORD $0x00da; BYTE $0x00 // leaq $56060(%rip), %rax /* __SingleQuoteTab(%rip) */ - LONG $0x063c8348; BYTE $0x00 // cmpq $0, (%rsi,%rax) - LONG $0x0112850f; WORD $0x0000 // jne LBB8_61, $274(%rip) - LONG $0x0f048d49 // leaq (%r15,%rcx), %rax - LONG $0x141c8841 // movb %bl, (%r12,%rdx) - LONG $0xff718d48 // leaq $-1(%rcx), %rsi - LONG $0x02f88348 // cmpq $2, %rax - LONG $0x00138c0f; WORD $0x0000 // jl LBB8_43, $19(%rip) - WORD $0x014c; BYTE $0xf1 // addq %r14, %rcx - WORD $0xff48; BYTE $0xc2 // incq %rdx - LONG $0x01f98348 // cmpq $1, %rcx - WORD $0x8948; BYTE $0xf1 // movq %rsi, %rcx - LONG $0xffb88f0f; WORD $0xffff // jg LBB8_40, $-72(%rip) +LBB5_22: + WORD $0xb70f; BYTE $0xc0 // movzwl %ax, %eax + WORD $0x294d; BYTE $0xdd // subq %r11, %r13 + LONG $0xf0bc0f44 // bsfl %eax, %r14d -LBB8_43: - WORD $0x2949; BYTE $0xf5 // subq %rsi, %r13 - WORD $0x0149; BYTE $0xf7 // addq %rsi, %r15 +LBB5_23: + WORD $0x014d; BYTE $0xee // addq %r13, %r14 + WORD $0x8949; BYTE $0xd7 // movq %rdx, %r15 + LONG $0x0002dfe9; BYTE $0x00 // jmp LBB5_71, $735(%rip) -LBB8_44: - WORD $0x854d; BYTE $0xff // testq %r15, %r15 - LONG $0xd0758b4c // movq $-48(%rbp), %r14 - QUAD $0x000300000001bc49; WORD $0x0000 // movabsq $12884901889, %r12 - LONG $0x00c0840f; WORD $0x0000 // je LBB8_59, $192(%rip) - WORD $0xf749; BYTE $0xd5 // notq %r13 - WORD $0x014d; BYTE $0xdd // addq %r11, %r13 - LONG $0x0000b8e9; BYTE $0x00 // jmp LBB8_60, $184(%rip) - -LBB8_46: - WORD $0x894c; BYTE $0xeb // movq %r13, %rbx +LBB5_24: + WORD $0x894c; BYTE $0xe8 // movq %r13, %rax WORD $0x894c; BYTE $0xf1 // movq %r14, %rcx LONG $0x08f98348 // cmpq $8, %rcx - LONG $0x0013820f; WORD $0x0000 // jb LBB8_48, $19(%rip) + LONG $0x0012820f; WORD $0x0000 // jb LBB5_26, $18(%rip) -LBB8_47: - WORD $0x8b48; BYTE $0x13 // movq (%rbx), %rdx - LONG $0x24148949 // movq %rdx, (%r12) - LONG $0x08c38348 // addq $8, %rbx - LONG $0x08c48349 // addq $8, %r12 +LBB5_25: + WORD $0x8b48; BYTE $0x10 // movq (%rax), %rdx + WORD $0x8948; BYTE $0x16 // movq %rdx, (%rsi) + LONG $0x08c08348 // addq $8, %rax + LONG $0x08c68348 // addq $8, %rsi LONG $0xf8c18348 // addq $-8, %rcx -LBB8_48: +LBB5_26: LONG $0x04f98348 // cmpq $4, %rcx - LONG $0x003a820f; WORD $0x0000 // jb LBB8_49, $58(%rip) - WORD $0x138b // movl (%rbx), %edx - LONG $0x24148941 // movl %edx, (%r12) - LONG $0x04c38348 // addq $4, %rbx - LONG $0x04c48349 // addq $4, %r12 + LONG $0x00358c0f; WORD $0x0000 // jl LBB5_27, $53(%rip) + WORD $0x108b // movl (%rax), %edx + WORD $0x1689 // movl %edx, (%rsi) + LONG $0x04c08348 // addq $4, %rax + LONG $0x04c68348 // addq $4, %rsi LONG $0xfcc18348 // addq $-4, %rcx LONG $0x02f98348 // cmpq $2, %rcx - LONG $0x0028830f; WORD $0x0000 // jae LBB8_56, $40(%rip) + LONG $0x0025830f; WORD $0x0000 // jae LBB5_50, $37(%rip) -LBB8_50: +LBB5_28: WORD $0x8548; BYTE $0xc9 // testq %rcx, %rcx - LONG $0x0007840f; WORD $0x0000 // je LBB8_52, $7(%rip) + LONG $0x0004840f; WORD $0x0000 // je LBB5_30, $4(%rip) -LBB8_51: - WORD $0xb60f; BYTE $0x0b // movzbl (%rbx), %ecx - LONG $0x240c8841 // movb %cl, (%r12) +LBB5_29: + WORD $0x008a // movb (%rax), %al + WORD $0x0688 // movb %al, (%rsi) -LBB8_52: - WORD $0x294d; BYTE $0xdd // subq %r11, %r13 - WORD $0x014d; BYTE $0xf5 // addq %r14, %r13 - WORD $0x8949; BYTE $0xf6 // movq %rsi, %r14 - LONG $0x000139e9; BYTE $0x00 // jmp LBB8_75, $313(%rip) +LBB5_30: + WORD $0x294d; BYTE $0xde // subq %r11, %r14 + WORD $0x014d; BYTE $0xee // addq %r13, %r14 + WORD $0xf749; BYTE $0xd6 // notq %r14 + LONG $0x00027ee9; BYTE $0x00 // jmp LBB5_71, $638(%rip) -LBB8_49: +LBB5_27: LONG $0x02f98348 // cmpq $2, %rcx - LONG $0xffd8820f; WORD $0xffff // jb LBB8_50, $-40(%rip) + LONG $0xffdb820f; WORD $0xffff // jb LBB5_28, $-37(%rip) -LBB8_56: - WORD $0xb70f; BYTE $0x13 // movzwl (%rbx), %edx - LONG $0x14894166; BYTE $0x24 // movw %dx, (%r12) - LONG $0x02c38348 // addq $2, %rbx - LONG $0x02c48349 // addq $2, %r12 +LBB5_50: + WORD $0xb70f; BYTE $0x10 // movzwl (%rax), %edx + WORD $0x8966; BYTE $0x16 // movw %dx, (%rsi) + LONG $0x02c08348 // addq $2, %rax + LONG $0x02c68348 // addq $2, %rsi LONG $0xfec18348 // addq $-2, %rcx WORD $0x8548; BYTE $0xc9 // testq %rcx, %rcx - LONG $0xffc4850f; WORD $0xffff // jne LBB8_51, $-60(%rip) - LONG $0xffffc6e9; BYTE $0xff // jmp LBB8_52, $-58(%rip) - -LBB8_57: - WORD $0xfb83; BYTE $0x08 // cmpl $8, %ebx - LONG $0xc87d8b4c // movq $-56(%rbp), %r15 - LONG $0x00ad820f; WORD $0x0000 // jb LBB8_69, $173(%rip) - LONG $0x240c8949 // movq %rcx, (%r12) - LONG $0x08558d49 // leaq $8(%r13), %rdx - LONG $0x08c48349 // addq $8, %r12 - LONG $0xf84b8d48 // leaq $-8(%rbx), %rcx - LONG $0x00009ee9; BYTE $0x00 // jmp LBB8_70, $158(%rip) + LONG $0xffc9850f; WORD $0xffff // jne LBB5_29, $-55(%rip) + LONG $0xffffc8e9; BYTE $0xff // jmp LBB5_30, $-56(%rip) -LBB8_59: - WORD $0x294d; BYTE $0xdd // subq %r11, %r13 +LBB5_31: + WORD $0x894c; BYTE $0xf3 // movq %r14, %rbx + WORD $0x894c; BYTE $0xf8 // movq %r15, %rax + QUAD $0xfffffbad256ffdc5 // vmovdqa $-1107(%rip), %ymm4 /* LCPI5_0(%rip) */ + QUAD $0xfffffbc52d6ffdc5 // vmovdqa $-1083(%rip), %ymm5 /* LCPI5_1(%rip) */ + QUAD $0xfffffbdd356ffdc5 // vmovdqa $-1059(%rip), %ymm6 /* LCPI5_2(%rip) */ + LONG $0x763d41c4; BYTE $0xc0 // vpcmpeqd %ymm8, %ymm8, %ymm8 + QUAD $0xfffffbf03d6ff9c5 // vmovdqa $-1040(%rip), %xmm7 /* LCPI5_3(%rip) */ + QUAD $0xfffffbf80d6f79c5 // vmovdqa $-1032(%rip), %xmm9 /* LCPI5_4(%rip) */ + QUAD $0xfffffc00156f79c5 // vmovdqa $-1024(%rip), %xmm10 /* LCPI5_5(%rip) */ + LONG $0x762141c4; BYTE $0xdb // vpcmpeqd %xmm11, %xmm11, %xmm11 + WORD $0xc984 // testb %cl, %cl + LONG $0x0030840f; WORD $0x0000 // je LBB5_37, $48(%rip) + LONG $0xfffe7be9; BYTE $0xff // jmp LBB5_33, $-389(%rip) + +LBB5_36: + WORD $0x894c; BYTE $0xf3 // movq %r14, %rbx + WORD $0x894c; BYTE $0xf8 // movq %r15, %rax + QUAD $0xfffffb60256ffdc5 // vmovdqa $-1184(%rip), %ymm4 /* LCPI5_0(%rip) */ + QUAD $0xfffffb782d6ffdc5 // vmovdqa $-1160(%rip), %ymm5 /* LCPI5_1(%rip) */ + QUAD $0xfffffb90356ffdc5 // vmovdqa $-1136(%rip), %ymm6 /* LCPI5_2(%rip) */ + LONG $0x763d41c4; BYTE $0xc0 // vpcmpeqd %ymm8, %ymm8, %ymm8 + WORD $0xc984 // testb %cl, %cl + LONG $0xfe50850f; WORD $0xffff // jne LBB5_33, $-432(%rip) -LBB8_60: - LONG $0xc87d8b4c // movq $-56(%rbp), %r15 - LONG $0x0000e9e9; BYTE $0x00 // jmp LBB8_76, $233(%rip) +LBB5_37: + WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx + WORD $0x8949; BYTE $0xd7 // movq %rdx, %r15 + LONG $0xc6358d4c; WORD $0x00d5; BYTE $0x00 // leaq $54726(%rip), %r14 /* __SingleQuoteTab(%rip) */ + LONG $0x01758e0f; WORD $0x0000 // jle LBB5_62, $373(%rip) + WORD $0x8948; BYTE $0xc1 // movq %rax, %rcx + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0x016c8e0f; WORD $0x0000 // jle LBB5_63, $364(%rip) + LONG $0x90909090 // .p2align 4, 0x90 -LBB8_61: - WORD $0x294d; BYTE $0xdd // subq %r11, %r13 - WORD $0x2949; BYTE $0xcd // subq %rcx, %r13 - LONG $0xc87d8b4c // movq $-56(%rbp), %r15 - LONG $0x000048e9; BYTE $0x00 // jmp LBB8_68, $72(%rip) +LBB5_39: + LONG $0x55b60f41; BYTE $0x00 // movzbl (%r13), %edx + WORD $0x8948; BYTE $0xd1 // movq %rdx, %rcx + LONG $0x04e1c148 // shlq $4, %rcx + LONG $0x313c834a; BYTE $0x00 // cmpq $0, (%rcx,%r14) + LONG $0x00d4850f; WORD $0x0000 // jne LBB5_55, $212(%rip) + LONG $0xff488d48 // leaq $-1(%rax), %rcx + WORD $0xff49; BYTE $0xc5 // incq %r13 + WORD $0x1688 // movb %dl, (%rsi) + LONG $0x02f88348 // cmpq $2, %rax + LONG $0x013e8c0f; WORD $0x0000 // jl LBB5_63, $318(%rip) + LONG $0xff538d48 // leaq $-1(%rbx), %rdx + WORD $0xff48; BYTE $0xc6 // incq %rsi + WORD $0x8948; BYTE $0xc8 // movq %rcx, %rax + LONG $0x01fb8348 // cmpq $1, %rbx + WORD $0x8948; BYTE $0xd3 // movq %rdx, %rbx + LONG $0xffbf8f0f; WORD $0xffff // jg LBB5_39, $-65(%rip) + LONG $0x000122e9; BYTE $0x00 // jmp LBB5_63, $290(%rip) -LBB8_62: - WORD $0x894c; BYTE $0xe9 // movq %r13, %rcx - WORD $0x894c; BYTE $0xf2 // movq %r14, %rdx +LBB5_42: + WORD $0x894c; BYTE $0xe8 // movq %r13, %rax + WORD $0x8948; BYTE $0xcb // movq %rcx, %rbx + LONG $0x08fb8348 // cmpq $8, %rbx + LONG $0x0012820f; WORD $0x0000 // jb LBB5_44, $18(%rip) -LBB8_63: - LONG $0x04fa8348 // cmpq $4, %rdx - LONG $0x00418c0f; WORD $0x0000 // jl LBB8_64, $65(%rip) - WORD $0x318b // movl (%rcx), %esi - LONG $0x24348941 // movl %esi, (%r12) - LONG $0x04c18348 // addq $4, %rcx - LONG $0x04c48349 // addq $4, %r12 - LONG $0xfcc28348 // addq $-4, %rdx - LONG $0x02fa8348 // cmpq $2, %rdx - LONG $0x002f830f; WORD $0x0000 // jae LBB8_90, $47(%rip) +LBB5_43: + WORD $0x8b48; BYTE $0x10 // movq (%rax), %rdx + WORD $0x8948; BYTE $0x16 // movq %rdx, (%rsi) + LONG $0x08c08348 // addq $8, %rax + LONG $0x08c68348 // addq $8, %rsi + LONG $0xf8c38348 // addq $-8, %rbx -LBB8_65: - WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx - LONG $0x0007840f; WORD $0x0000 // je LBB8_67, $7(%rip) +LBB5_44: + LONG $0x04fb8348 // cmpq $4, %rbx + LONG $0x00328c0f; WORD $0x0000 // jl LBB5_45, $50(%rip) + WORD $0x108b // movl (%rax), %edx + WORD $0x1689 // movl %edx, (%rsi) + LONG $0x04c08348 // addq $4, %rax + LONG $0x04c68348 // addq $4, %rsi + LONG $0xfcc38348 // addq $-4, %rbx + LONG $0x02fb8348 // cmpq $2, %rbx + LONG $0x0022830f; WORD $0x0000 // jae LBB5_52, $34(%rip) -LBB8_66: - WORD $0xb60f; BYTE $0x09 // movzbl (%rcx), %ecx - LONG $0x240c8841 // movb %cl, (%r12) +LBB5_46: + WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx + LONG $0x0004840f; WORD $0x0000 // je LBB5_48, $4(%rip) -LBB8_67: - WORD $0x014d; BYTE $0xee // addq %r13, %r14 - WORD $0xf749; BYTE $0xd6 // notq %r14 - WORD $0x014d; BYTE $0xde // addq %r11, %r14 - WORD $0x894d; BYTE $0xf5 // movq %r14, %r13 +LBB5_47: + WORD $0x008a // movb (%rax), %al + WORD $0x0688 // movb %al, (%rsi) -LBB8_68: - LONG $0xd0758b4c // movq $-48(%rbp), %r14 - LONG $0x00007fe9; BYTE $0x00 // jmp LBB8_75, $127(%rip) +LBB5_48: + WORD $0x294d; BYTE $0xdd // subq %r11, %r13 + WORD $0x0149; BYTE $0xcd // addq %rcx, %r13 + LONG $0x000112e9; BYTE $0x00 // jmp LBB5_70, $274(%rip) -LBB8_64: - LONG $0x02fa8348 // cmpq $2, %rdx - LONG $0xffd1820f; WORD $0xffff // jb LBB8_65, $-47(%rip) +LBB5_45: + LONG $0x02fb8348 // cmpq $2, %rbx + LONG $0xffde820f; WORD $0xffff // jb LBB5_46, $-34(%rip) -LBB8_90: - WORD $0xb70f; BYTE $0x31 // movzwl (%rcx), %esi - LONG $0x34894166; BYTE $0x24 // movw %si, (%r12) - LONG $0x02c18348 // addq $2, %rcx - LONG $0x02c48349 // addq $2, %r12 - LONG $0xfec28348 // addq $-2, %rdx - WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx - LONG $0xffbd850f; WORD $0xffff // jne LBB8_66, $-67(%rip) - LONG $0xffffbfe9; BYTE $0xff // jmp LBB8_67, $-65(%rip) +LBB5_52: + WORD $0xb70f; BYTE $0x10 // movzwl (%rax), %edx + WORD $0x8966; BYTE $0x16 // movw %dx, (%rsi) + LONG $0x02c08348 // addq $2, %rax + LONG $0x02c68348 // addq $2, %rsi + LONG $0xfec38348 // addq $-2, %rbx + WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx + LONG $0xffcc850f; WORD $0xffff // jne LBB5_47, $-52(%rip) + LONG $0xffffcbe9; BYTE $0xff // jmp LBB5_48, $-53(%rip) -LBB8_69: - WORD $0x894c; BYTE $0xea // movq %r13, %rdx +LBB5_53: + WORD $0xf883; BYTE $0x08 // cmpl $8, %eax + LONG $0x00a2820f; WORD $0x0000 // jb LBB5_64, $162(%rip) + WORD $0x8948; BYTE $0x0e // movq %rcx, (%rsi) + LONG $0x084d8d49 // leaq $8(%r13), %rcx + LONG $0x08c68348 // addq $8, %rsi + LONG $0xf8588d48 // leaq $-8(%rax), %rbx + LONG $0x000094e9; BYTE $0x00 // jmp LBB5_65, $148(%rip) + +LBB5_55: + WORD $0x294d; BYTE $0xdd // subq %r11, %r13 + LONG $0x0000c3e9; BYTE $0x00 // jmp LBB5_70, $195(%rip) + +LBB5_56: + WORD $0x894c; BYTE $0xe8 // movq %r13, %rax WORD $0x8948; BYTE $0xd9 // movq %rbx, %rcx -LBB8_70: - LONG $0xd0758b4c // movq $-48(%rbp), %r14 +LBB5_57: LONG $0x04f98348 // cmpq $4, %rcx - LONG $0x0126820f; WORD $0x0000 // jb LBB8_71, $294(%rip) - WORD $0x328b // movl (%rdx), %esi - LONG $0x24348941 // movl %esi, (%r12) - LONG $0x04c28348 // addq $4, %rdx - LONG $0x04c48349 // addq $4, %r12 + LONG $0x00388c0f; WORD $0x0000 // jl LBB5_58, $56(%rip) + WORD $0x108b // movl (%rax), %edx + WORD $0x1689 // movl %edx, (%rsi) + LONG $0x04c08348 // addq $4, %rax + LONG $0x04c68348 // addq $4, %rsi LONG $0xfcc18348 // addq $-4, %rcx LONG $0x02f98348 // cmpq $2, %rcx - LONG $0x0114830f; WORD $0x0000 // jae LBB8_92, $276(%rip) + LONG $0x0028830f; WORD $0x0000 // jae LBB5_85, $40(%rip) -LBB8_72: +LBB5_59: WORD $0x8548; BYTE $0xc9 // testq %rcx, %rcx - LONG $0x0007840f; WORD $0x0000 // je LBB8_74, $7(%rip) + LONG $0x0004840f; WORD $0x0000 // je LBB5_61, $4(%rip) -LBB8_73: - WORD $0xb60f; BYTE $0x0a // movzbl (%rdx), %ecx - LONG $0x240c8841 // movb %cl, (%r12) +LBB5_60: + WORD $0x008a // movb (%rax), %al + WORD $0x0688 // movb %al, (%rsi) -LBB8_74: - WORD $0x294d; BYTE $0xdd // subq %r11, %r13 - WORD $0x0149; BYTE $0xdd // addq %rbx, %r13 - QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 +LBB5_61: + WORD $0x294c; BYTE $0xdb // subq %r11, %rbx + WORD $0x014c; BYTE $0xeb // addq %r13, %rbx + WORD $0xf748; BYTE $0xd3 // notq %rbx + WORD $0x8949; BYTE $0xde // movq %rbx, %r14 + LONG $0x00007ee9; BYTE $0x00 // jmp LBB5_71, $126(%rip) -LBB8_75: - QUAD $0x000300000001bc49; WORD $0x0000 // movabsq $12884901889, %r12 - -LBB8_76: - WORD $0x854d; BYTE $0xed // testq %r13, %r13 - LONG $0x0425880f; WORD $0x0000 // js LBB8_125, $1061(%rip) - WORD $0x014d; BYTE $0xe9 // addq %r13, %r9 - WORD $0x394d; BYTE $0xee // cmpq %r13, %r14 - LONG $0x03d9840f; WORD $0x0000 // je LBB8_121, $985(%rip) - WORD $0x294d; BYTE $0xea // subq %r13, %r10 - LONG $0x000018e9; BYTE $0x00 // jmp LBB8_80, $24(%rip) - QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90 +LBB5_58: + LONG $0x02f98348 // cmpq $2, %rcx + LONG $0xffd8820f; WORD $0xffff // jb LBB5_59, $-40(%rip) -LBB8_79: - WORD $0x0149; BYTE $0xc9 // addq %rcx, %r9 - WORD $0xff49; BYTE $0xc5 // incq %r13 - WORD $0x394d; BYTE $0xee // cmpq %r13, %r14 - LONG $0x03b9840f; WORD $0x0000 // je LBB8_121, $953(%rip) - -LBB8_80: - LONG $0x14b60f43; BYTE $0x2b // movzbl (%r11,%r13), %edx - LONG $0x04e2c148 // shlq $4, %rdx - LONG $0x10348b41 // movl (%r8,%rdx), %esi - WORD $0x8548; BYTE $0xf6 // testq %rsi, %rsi - LONG $0x0080840f; WORD $0x0000 // je LBB8_88, $128(%rip) - WORD $0x6348; BYTE $0xce // movslq %esi, %rcx - WORD $0x2949; BYTE $0xca // subq %rcx, %r10 - LONG $0x03af8c0f; WORD $0x0000 // jl LBB8_123, $943(%rip) - LONG $0x20e6c148 // shlq $32, %rsi - WORD $0x014c; BYTE $0xc2 // addq %r8, %rdx - LONG $0x08c28348 // addq $8, %rdx - WORD $0x394c; BYTE $0xe6 // cmpq %r12, %rsi - LONG $0x002b8c0f; WORD $0x0000 // jl LBB8_84, $43(%rip) - WORD $0x028b // movl (%rdx), %eax - WORD $0x8941; BYTE $0x01 // movl %eax, (%r9) - LONG $0x04c28348 // addq $4, %rdx - LONG $0x04718d49 // leaq $4(%r9), %rsi - LONG $0xfc598d48 // leaq $-4(%rcx), %rbx - LONG $0x02fb8348 // cmpq $2, %rbx - LONG $0x0020830f; WORD $0x0000 // jae LBB8_85, $32(%rip) - LONG $0x00002de9; BYTE $0x00 // jmp LBB8_86, $45(%rip) - QUAD $0x9090909090909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 +LBB5_85: + WORD $0xb70f; BYTE $0x10 // movzwl (%rax), %edx + WORD $0x8966; BYTE $0x16 // movw %dx, (%rsi) + LONG $0x02c08348 // addq $2, %rax + LONG $0x02c68348 // addq $2, %rsi + LONG $0xfec18348 // addq $-2, %rcx + WORD $0x8548; BYTE $0xc9 // testq %rcx, %rcx + LONG $0xffc6850f; WORD $0xffff // jne LBB5_60, $-58(%rip) + LONG $0xffffc5e9; BYTE $0xff // jmp LBB5_61, $-59(%rip) -LBB8_84: - WORD $0x894c; BYTE $0xce // movq %r9, %rsi - WORD $0x8948; BYTE $0xcb // movq %rcx, %rbx +LBB5_62: + WORD $0x8948; BYTE $0xc1 // movq %rax, %rcx + +LBB5_63: + WORD $0x294d; BYTE $0xdd // subq %r11, %r13 + WORD $0xf748; BYTE $0xd9 // negq %rcx + WORD $0x194d; BYTE $0xf6 // sbbq %r14, %r14 + WORD $0x314d; BYTE $0xee // xorq %r13, %r14 + LONG $0x000040e9; BYTE $0x00 // jmp LBB5_71, $64(%rip) + +LBB5_64: + WORD $0x894c; BYTE $0xe9 // movq %r13, %rcx + WORD $0x8948; BYTE $0xc3 // movq %rax, %rbx + +LBB5_65: + LONG $0x04fb8348 // cmpq $4, %rbx + LONG $0x01228c0f; WORD $0x0000 // jl LBB5_66, $290(%rip) + WORD $0x118b // movl (%rcx), %edx + WORD $0x1689 // movl %edx, (%rsi) + LONG $0x04c18348 // addq $4, %rcx + LONG $0x04c68348 // addq $4, %rsi + LONG $0xfcc38348 // addq $-4, %rbx + LONG $0x02fb8348 // cmpq $2, %rbx + LONG $0x0112830f; WORD $0x0000 // jae LBB5_87, $274(%rip) + +LBB5_67: + WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx + LONG $0x0004840f; WORD $0x0000 // je LBB5_69, $4(%rip) + +LBB5_68: + WORD $0x098a // movb (%rcx), %cl + WORD $0x0e88 // movb %cl, (%rsi) + +LBB5_69: + WORD $0x294d; BYTE $0xdd // subq %r11, %r13 + WORD $0x0149; BYTE $0xc5 // addq %rax, %r13 + +LBB5_70: + WORD $0x894d; BYTE $0xee // movq %r13, %r14 + +LBB5_71: + WORD $0x854d; BYTE $0xf6 // testq %r14, %r14 + LONG $0xd0558b48 // movq $-48(%rbp), %rdx + QUAD $0x000300000001bd49; WORD $0x0000 // movabsq $12884901889, %r13 + LONG $0x0481880f; WORD $0x0000 // js LBB5_124, $1153(%rip) + WORD $0x014d; BYTE $0xf3 // addq %r14, %r11 + WORD $0x014d; BYTE $0xf4 // addq %r14, %r12 + WORD $0x394d; BYTE $0xf2 // cmpq %r14, %r10 + LONG $0x0440840f; WORD $0x0000 // je LBB5_120, $1088(%rip) + WORD $0x294d; BYTE $0xf1 // subq %r14, %r9 + WORD $0x294d; BYTE $0xd6 // subq %r10, %r14 + LONG $0x000015e9; BYTE $0x00 // jmp LBB5_75, $21(%rip) + LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 + +LBB5_74: + WORD $0xff49; BYTE $0xc3 // incq %r11 + WORD $0x0149; BYTE $0xc4 // addq %rax, %r12 + WORD $0xff49; BYTE $0xc6 // incq %r14 + LONG $0x0420840f; WORD $0x0000 // je LBB5_120, $1056(%rip) + +LBB5_75: + LONG $0x33b60f41 // movzbl (%r11), %esi + LONG $0x04e6c148 // shlq $4, %rsi + LONG $0x301c8b49 // movq (%r8,%rsi), %rbx + WORD $0xdb85 // testl %ebx, %ebx + LONG $0x0084840f; WORD $0x0000 // je LBB5_83, $132(%rip) + WORD $0x6348; BYTE $0xc3 // movslq %ebx, %rax + WORD $0x2949; BYTE $0xc1 // subq %rax, %r9 + LONG $0x040e8c0f; WORD $0x0000 // jl LBB5_121, $1038(%rip) + LONG $0x20e3c148 // shlq $32, %rbx + LONG $0x304c8d49; BYTE $0x08 // leaq $8(%r8,%rsi), %rcx + WORD $0x394c; BYTE $0xeb // cmpq %r13, %rbx + LONG $0x002f8c0f; WORD $0x0000 // jl LBB5_79, $47(%rip) + WORD $0x098b // movl (%rcx), %ecx + LONG $0x240c8941 // movl %ecx, (%r12) + LONG $0x304c8d49; BYTE $0x0c // leaq $12(%r8,%rsi), %rcx + LONG $0x24548d4d; BYTE $0x04 // leaq $4(%r12), %r10 + LONG $0xfc588d48 // leaq $-4(%rax), %rbx + LONG $0x02fb8348 // cmpq $2, %rbx + LONG $0x0021830f; WORD $0x0000 // jae LBB5_80, $33(%rip) + LONG $0x00002fe9; BYTE $0x00 // jmp LBB5_81, $47(%rip) + QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90 + +LBB5_79: + WORD $0x894d; BYTE $0xe2 // movq %r12, %r10 + WORD $0x8948; BYTE $0xc3 // movq %rax, %rbx LONG $0x02fb8348 // cmpq $2, %rbx - LONG $0x0012820f; WORD $0x0000 // jb LBB8_86, $18(%rip) + LONG $0x0013820f; WORD $0x0000 // jb LBB5_81, $19(%rip) -LBB8_85: - WORD $0xb70f; BYTE $0x02 // movzwl (%rdx), %eax - WORD $0x8966; BYTE $0x06 // movw %ax, (%rsi) - LONG $0x02c28348 // addq $2, %rdx - LONG $0x02c68348 // addq $2, %rsi +LBB5_80: + WORD $0xb70f; BYTE $0x31 // movzwl (%rcx), %esi + LONG $0x32894166 // movw %si, (%r10) + LONG $0x02c18348 // addq $2, %rcx + LONG $0x02c28349 // addq $2, %r10 LONG $0xfec38348 // addq $-2, %rbx -LBB8_86: +LBB5_81: WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx - LONG $0xff65840f; WORD $0xffff // je LBB8_79, $-155(%rip) - WORD $0xb60f; BYTE $0x02 // movzbl (%rdx), %eax - WORD $0x0688 // movb %al, (%rsi) - LONG $0xffff5be9; BYTE $0xff // jmp LBB8_79, $-165(%rip) - -LBB8_88: - LONG $0x2b0c8d4b // leaq (%r11,%r13), %rcx - WORD $0x294d; BYTE $0xee // subq %r13, %r14 - LONG $0xf950850f; WORD $0xffff // jne LBB8_3, $-1712(%rip) - LONG $0x000311e9; BYTE $0x00 // jmp LBB8_121, $785(%rip) - -LBB8_71: - LONG $0x02f98348 // cmpq $2, %rcx - LONG $0xfeec820f; WORD $0xffff // jb LBB8_72, $-276(%rip) + LONG $0xff64840f; WORD $0xffff // je LBB5_74, $-156(%rip) + WORD $0xb60f; BYTE $0x09 // movzbl (%rcx), %ecx + WORD $0x8841; BYTE $0x0a // movb %cl, (%r10) + LONG $0xffff59e9; BYTE $0xff // jmp LBB5_74, $-167(%rip) -LBB8_92: - WORD $0xb70f; BYTE $0x32 // movzwl (%rdx), %esi - LONG $0x34894166; BYTE $0x24 // movw %si, (%r12) - LONG $0x02c28348 // addq $2, %rdx - LONG $0x02c48349 // addq $2, %r12 - LONG $0xfec18348 // addq $-2, %rcx - WORD $0x8548; BYTE $0xc9 // testq %rcx, %rcx - LONG $0xfed8850f; WORD $0xffff // jne LBB8_73, $-296(%rip) - LONG $0xfffedae9; BYTE $0xff // jmp LBB8_74, $-294(%rip) - -LBB8_93: - LONG $0xe60d8d4c; WORD $0x00f7; BYTE $0x00 // leaq $63462(%rip), %r9 /* __EscTab(%rip) */ - QUAD $0xfffff80e1d6ffdc5 // vmovdqa $-2034(%rip), %ymm3 /* LCPI8_0(%rip) */ - QUAD $0xfffff826056f7dc5 // vmovdqa $-2010(%rip), %ymm8 /* LCPI8_1(%rip) */ - QUAD $0xfffff83e2d6ffdc5 // vmovdqa $-1986(%rip), %ymm5 /* LCPI8_2(%rip) */ - WORD $0x8948; BYTE $0xd3 // movq %rdx, %rbx - WORD $0x894c; BYTE $0xf6 // movq %r14, %rsi +LBB5_83: + WORD $0x894d; BYTE $0xf2 // movq %r14, %r10 + WORD $0xf749; BYTE $0xda // negq %r10 + WORD $0x854d; BYTE $0xf6 // testq %r14, %r14 + LONG $0xf97e850f; WORD $0xffff // jne LBB5_3, $-1666(%rip) + LONG $0x000374e9; BYTE $0x00 // jmp LBB5_120, $884(%rip) -LBB8_94: - LONG $0x10fe8348 // cmpq $16, %rsi - LONG $0x01108c0f; WORD $0x0000 // jl LBB8_102, $272(%rip) - LONG $0x20fe8348 // cmpq $32, %rsi - LONG $0x0088820f; WORD $0x0000 // jb LBB8_99, $136(%rip) - LONG $0x90909090 // .p2align 4, 0x90 +LBB5_66: + LONG $0x02fb8348 // cmpq $2, %rbx + LONG $0xfeee820f; WORD $0xffff // jb LBB5_67, $-274(%rip) -LBB8_96: - LONG $0x076ffec5 // vmovdqu (%rdi), %ymm0 - LONG $0xcb74fdc5 // vpcmpeqb %ymm3, %ymm0, %ymm1 - LONG $0xd074bdc5 // vpcmpeqb %ymm0, %ymm8, %ymm2 - LONG $0xc9ebedc5 // vpor %ymm1, %ymm2, %ymm1 - LONG $0x037ffec5 // vmovdqu %ymm0, (%rbx) - LONG $0xd5dafdc5 // vpminub %ymm5, %ymm0, %ymm2 - LONG $0xc274fdc5 // vpcmpeqb %ymm2, %ymm0, %ymm0 - LONG $0xc0ebf5c5 // vpor %ymm0, %ymm1, %ymm0 - LONG $0xc0d7fdc5 // vpmovmskb %ymm0, %eax - WORD $0xc085 // testl %eax, %eax - LONG $0x01ff850f; WORD $0x0000 // jne LBB8_114, $511(%rip) - LONG $0x20c78348 // addq $32, %rdi - LONG $0x20c38348 // addq $32, %rbx - LONG $0xe0c68348 // addq $-32, %rsi - LONG $0x1ffe8348 // cmpq $31, %rsi - LONG $0xffbe870f; WORD $0xffff // ja LBB8_96, $-66(%rip) - WORD $0xf8c5; BYTE $0x77 // vzeroupper - QUAD $0xfffff7d32d6ffdc5 // vmovdqa $-2093(%rip), %ymm5 /* LCPI8_2(%rip) */ - QUAD $0xfffff7ab056f7dc5 // vmovdqa $-2133(%rip), %ymm8 /* LCPI8_1(%rip) */ - QUAD $0xfffff7831d6ffdc5 // vmovdqa $-2173(%rip), %ymm3 /* LCPI8_0(%rip) */ - LONG $0x10fe8348 // cmpq $16, %rsi - QUAD $0xfffff7d7356ff9c5 // vmovdqa $-2089(%rip), %xmm6 /* LCPI8_3(%rip) */ - QUAD $0xfffff7df3d6ff9c5 // vmovdqa $-2081(%rip), %xmm7 /* LCPI8_4(%rip) */ - QUAD $0xfffff7e7256ff9c5 // vmovdqa $-2073(%rip), %xmm4 /* LCPI8_5(%rip) */ - LONG $0x0041830f; WORD $0x0000 // jae LBB8_100, $65(%rip) - LONG $0x00007ee9; BYTE $0x00 // jmp LBB8_102, $126(%rip) - -LBB8_99: - WORD $0xf8c5; BYTE $0x77 // vzeroupper - QUAD $0xfffff7912d6ffdc5 // vmovdqa $-2159(%rip), %ymm5 /* LCPI8_2(%rip) */ - QUAD $0xfffff769056f7dc5 // vmovdqa $-2199(%rip), %ymm8 /* LCPI8_1(%rip) */ - QUAD $0xfffff7411d6ffdc5 // vmovdqa $-2239(%rip), %ymm3 /* LCPI8_0(%rip) */ - QUAD $0xfffff799356ff9c5 // vmovdqa $-2151(%rip), %xmm6 /* LCPI8_3(%rip) */ - QUAD $0xfffff7a13d6ff9c5 // vmovdqa $-2143(%rip), %xmm7 /* LCPI8_4(%rip) */ - QUAD $0xfffff7a9256ff9c5 // vmovdqa $-2135(%rip), %xmm4 /* LCPI8_5(%rip) */ - QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90 +LBB5_87: + WORD $0xb70f; BYTE $0x11 // movzwl (%rcx), %edx + WORD $0x8966; BYTE $0x16 // movw %dx, (%rsi) + LONG $0x02c18348 // addq $2, %rcx + LONG $0x02c68348 // addq $2, %rsi + LONG $0xfec38348 // addq $-2, %rbx + WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx + LONG $0xfedc850f; WORD $0xffff // jne LBB5_68, $-292(%rip) + LONG $0xfffedbe9; BYTE $0xff // jmp LBB5_69, $-293(%rip) + +LBB5_88: + LONG $0xd40d8d4c; WORD $0x00f2; BYTE $0x00 // leaq $62164(%rip), %r9 /* __EscTab(%rip) */ + QUAD $0xfffff83c156f7dc5 // vmovdqa $-1988(%rip), %ymm10 /* LCPI5_0(%rip) */ + QUAD $0xfffff8540d6f7dc5 // vmovdqa $-1964(%rip), %ymm9 /* LCPI5_1(%rip) */ + QUAD $0xfffff86c1d6f7dc5 // vmovdqa $-1940(%rip), %ymm11 /* LCPI5_2(%rip) */ + LONG $0x763d41c4; BYTE $0xc0 // vpcmpeqd %ymm8, %ymm8, %ymm8 + WORD $0x8948; BYTE $0xd3 // movq %rdx, %rbx + WORD $0x894d; BYTE $0xd3 // movq %r10, %r11 -LBB8_100: - LONG $0x076ffac5 // vmovdqu (%rdi), %xmm0 - LONG $0xce74f9c5 // vpcmpeqb %xmm6, %xmm0, %xmm1 - LONG $0xd774f9c5 // vpcmpeqb %xmm7, %xmm0, %xmm2 - LONG $0xc9ebe9c5 // vpor %xmm1, %xmm2, %xmm1 - LONG $0x037ffac5 // vmovdqu %xmm0, (%rbx) - LONG $0xd4daf9c5 // vpminub %xmm4, %xmm0, %xmm2 - LONG $0xc274f9c5 // vpcmpeqb %xmm2, %xmm0, %xmm0 - LONG $0xc0ebf1c5 // vpor %xmm0, %xmm1, %xmm0 - LONG $0xc0d7f9c5 // vpmovmskb %xmm0, %eax - WORD $0xc085 // testl %eax, %eax - LONG $0x0130850f; WORD $0x0000 // jne LBB8_112, $304(%rip) - LONG $0x10c78348 // addq $16, %rdi - LONG $0x10c38348 // addq $16, %rbx - LONG $0xf0c68348 // addq $-16, %rsi - LONG $0x0ffe8348 // cmpq $15, %rsi - LONG $0xffbe870f; WORD $0xffff // ja LBB8_100, $-66(%rip) +LBB5_89: + LONG $0x10fb8349 // cmpq $16, %r11 + LONG $0x01278d0f; WORD $0x0000 // jge LBB5_90, $295(%rip) -LBB8_102: - LONG $0x08fe8348 // cmpq $8, %rsi - LONG $0x00818c0f; WORD $0x0000 // jl LBB8_106, $129(%rip) +LBB5_95: + LONG $0x08fb8349 // cmpq $8, %r11 + LONG $0x00858c0f; WORD $0x0000 // jl LBB5_99, $133(%rip) + +LBB5_96: WORD $0xb60f; BYTE $0x07 // movzbl (%rdi), %eax + LONG $0x04b60f42; BYTE $0x08 // movzbl (%rax,%r9), %eax LONG $0x014fb60f // movzbl $1(%rdi), %ecx LONG $0x0cb60f42; BYTE $0x09 // movzbl (%rcx,%r9), %ecx - WORD $0xc900 // addb %cl, %cl - LONG $0x080c0a42 // orb (%rax,%r9), %cl + WORD $0xc901 // addl %ecx, %ecx + WORD $0xc109 // orl %eax, %ecx LONG $0x0247b60f // movzbl $2(%rdi), %eax - LONG $0x14b60f46; BYTE $0x08 // movzbl (%rax,%r9), %r10d - LONG $0x02e2c041 // shlb $2, %r10b - WORD $0x0841; BYTE $0xca // orb %cl, %r10b + LONG $0x34b60f42; BYTE $0x08 // movzbl (%rax,%r9), %esi + WORD $0xe6c1; BYTE $0x02 // shll $2, %esi LONG $0x0347b60f // movzbl $3(%rdi), %eax LONG $0x04b60f42; BYTE $0x08 // movzbl (%rax,%r9), %eax - WORD $0xe0c0; BYTE $0x03 // shlb $3, %al - WORD $0x0844; BYTE $0xd0 // orb %r10b, %al + WORD $0xe0c1; BYTE $0x03 // shll $3, %eax + WORD $0xf009 // orl %esi, %eax + WORD $0xc809 // orl %ecx, %eax WORD $0x8b48; BYTE $0x0f // movq (%rdi), %rcx WORD $0x8948; BYTE $0x0b // movq %rcx, (%rbx) - LONG $0x00df850f; WORD $0x0000 // jne LBB8_113, $223(%rip) + WORD $0xc084 // testb %al, %al + LONG $0x029b850f; WORD $0x0000 // jne LBB5_117, $667(%rip) LONG $0x0447b60f // movzbl $4(%rdi), %eax + LONG $0x04b60f42; BYTE $0x08 // movzbl (%rax,%r9), %eax LONG $0x054fb60f // movzbl $5(%rdi), %ecx LONG $0x0cb60f42; BYTE $0x09 // movzbl (%rcx,%r9), %ecx - WORD $0xc900 // addb %cl, %cl - LONG $0x080c0a42 // orb (%rax,%r9), %cl + WORD $0xc901 // addl %ecx, %ecx + WORD $0xc109 // orl %eax, %ecx LONG $0x0647b60f // movzbl $6(%rdi), %eax - LONG $0x14b60f46; BYTE $0x08 // movzbl (%rax,%r9), %r10d - LONG $0x02e2c041 // shlb $2, %r10b - WORD $0x0841; BYTE $0xca // orb %cl, %r10b + LONG $0x34b60f42; BYTE $0x08 // movzbl (%rax,%r9), %esi + WORD $0xe6c1; BYTE $0x02 // shll $2, %esi LONG $0x0747b60f // movzbl $7(%rdi), %eax LONG $0x04b60f42; BYTE $0x08 // movzbl (%rax,%r9), %eax - WORD $0xe0c0; BYTE $0x03 // shlb $3, %al - WORD $0x0844; BYTE $0xd0 // orb %r10b, %al - LONG $0x00fc850f; WORD $0x0000 // jne LBB8_119, $252(%rip) + WORD $0xe0c1; BYTE $0x03 // shll $3, %eax + WORD $0xf009 // orl %esi, %eax + WORD $0xc809 // orl %ecx, %eax + WORD $0xc084 // testb %al, %al + LONG $0x026f850f; WORD $0x0000 // jne LBB5_118, $623(%rip) LONG $0x08c38348 // addq $8, %rbx LONG $0x08c78348 // addq $8, %rdi - LONG $0xf8c68348 // addq $-8, %rsi + LONG $0xf8c38349 // addq $-8, %r11 -LBB8_106: - LONG $0x04fe8348 // cmpq $4, %rsi - LONG $0x00478c0f; WORD $0x0000 // jl LBB8_109, $71(%rip) +LBB5_99: + LONG $0x04fb8349 // cmpq $4, %r11 + LONG $0x00498c0f; WORD $0x0000 // jl LBB5_102, $73(%rip) WORD $0xb60f; BYTE $0x07 // movzbl (%rdi), %eax + LONG $0x04b60f42; BYTE $0x08 // movzbl (%rax,%r9), %eax LONG $0x014fb60f // movzbl $1(%rdi), %ecx LONG $0x0cb60f42; BYTE $0x09 // movzbl (%rcx,%r9), %ecx - WORD $0xc900 // addb %cl, %cl - LONG $0x080c0a42 // orb (%rax,%r9), %cl + WORD $0xc901 // addl %ecx, %ecx + WORD $0xc109 // orl %eax, %ecx LONG $0x0247b60f // movzbl $2(%rdi), %eax - LONG $0x14b60f46; BYTE $0x08 // movzbl (%rax,%r9), %r10d - LONG $0x02e2c041 // shlb $2, %r10b - WORD $0x0841; BYTE $0xca // orb %cl, %r10b + LONG $0x34b60f42; BYTE $0x08 // movzbl (%rax,%r9), %esi + WORD $0xe6c1; BYTE $0x02 // shll $2, %esi LONG $0x0347b60f // movzbl $3(%rdi), %eax LONG $0x04b60f42; BYTE $0x08 // movzbl (%rax,%r9), %eax - WORD $0xe0c0; BYTE $0x03 // shlb $3, %al - WORD $0x0844; BYTE $0xd0 // orb %r10b, %al + WORD $0xe0c1; BYTE $0x03 // shll $3, %eax + WORD $0xf009 // orl %esi, %eax + WORD $0xc809 // orl %ecx, %eax WORD $0x0f8b // movl (%rdi), %ecx WORD $0x0b89 // movl %ecx, (%rbx) - LONG $0x0056850f; WORD $0x0000 // jne LBB8_113, $86(%rip) + WORD $0xc084 // testb %al, %al + LONG $0x020e850f; WORD $0x0000 // jne LBB5_117, $526(%rip) LONG $0x04c38348 // addq $4, %rbx LONG $0x04c78348 // addq $4, %rdi - LONG $0xfcc68348 // addq $-4, %rsi + LONG $0xfcc38349 // addq $-4, %r11 -LBB8_109: - WORD $0x8548; BYTE $0xf6 // testq %rsi, %rsi - LONG $0x00b68e0f; WORD $0x0000 // jle LBB8_120, $182(%rip) - QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90 +LBB5_102: + WORD $0x854d; BYTE $0xdb // testq %r11, %r11 + LONG $0x02208e0f; WORD $0x0000 // jle LBB5_119, $544(%rip) + QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90 -LBB8_110: +LBB5_103: WORD $0xb60f; BYTE $0x07 // movzbl (%rdi), %eax LONG $0x083c8042; BYTE $0x00 // cmpb $0, (%rax,%r9) - LONG $0x0039850f; WORD $0x0000 // jne LBB8_116, $57(%rip) + LONG $0x0194850f; WORD $0x0000 // jne LBB5_114, $404(%rip) WORD $0xff48; BYTE $0xc7 // incq %rdi WORD $0x0388 // movb %al, (%rbx) WORD $0xff48; BYTE $0xc3 // incq %rbx - LONG $0xff468d48 // leaq $-1(%rsi), %rax - LONG $0x01fe8348 // cmpq $1, %rsi - WORD $0x8948; BYTE $0xc6 // movq %rax, %rsi - LONG $0xffd98f0f; WORD $0xffff // jg LBB8_110, $-39(%rip) - LONG $0x000081e9; BYTE $0x00 // jmp LBB8_120, $129(%rip) + LONG $0xff438d49 // leaq $-1(%r11), %rax + LONG $0x01fb8349 // cmpq $1, %r11 + WORD $0x8949; BYTE $0xc3 // movq %rax, %r11 + LONG $0xffd98f0f; WORD $0xffff // jg LBB5_103, $-39(%rip) + LONG $0x0001e8e9; BYTE $0x00 // jmp LBB5_119, $488(%rip) + LONG $0x90909090 // .p2align 4, 0x90 -LBB8_112: - LONG $0xc0bc0f66 // bsfw %ax, %ax - WORD $0xb70f; BYTE $0xc0 // movzwl %ax, %eax - LONG $0x000006e9; BYTE $0x00 // jmp LBB8_115, $6(%rip) +LBB5_90: + LONG $0x20fb8349 // cmpq $32, %r11 + LONG $0x009f8c0f; WORD $0x0000 // jl LBB5_105, $159(%rip) + LONG $0x204b8d49 // leaq $32(%r11), %rcx + WORD $0xc031 // xorl %eax, %eax + + // .p2align 4, 0x90 +LBB5_92: + LONG $0x046ffec5; BYTE $0x07 // vmovdqu (%rdi,%rax), %ymm0 + LONG $0xc864adc5 // vpcmpgtb %ymm0, %ymm10, %ymm1 + LONG $0xd074b5c5 // vpcmpeqb %ymm0, %ymm9, %ymm2 + LONG $0xd874a5c5 // vpcmpeqb %ymm0, %ymm11, %ymm3 + LONG $0xd2ebe5c5 // vpor %ymm2, %ymm3, %ymm2 + LONG $0x047ffec5; BYTE $0x03 // vmovdqu %ymm0, (%rbx,%rax) + LONG $0x647dc1c4; BYTE $0xc0 // vpcmpgtb %ymm8, %ymm0, %ymm0 + LONG $0xc0dbf5c5 // vpand %ymm0, %ymm1, %ymm0 + LONG $0xc0ebedc5 // vpor %ymm0, %ymm2, %ymm0 + LONG $0xf0d7fdc5 // vpmovmskb %ymm0, %esi + WORD $0xf685 // testl %esi, %esi + LONG $0x011a850f; WORD $0x0000 // jne LBB5_111, $282(%rip) + LONG $0x20c08348 // addq $32, %rax + LONG $0xe0c18348 // addq $-32, %rcx + LONG $0x3ff98348 // cmpq $63, %rcx + LONG $0xffbb8f0f; WORD $0xffff // jg LBB5_92, $-69(%rip) + WORD $0xf8c5; BYTE $0x77 // vzeroupper + LONG $0x763d41c4; BYTE $0xc0 // vpcmpeqd %ymm8, %ymm8, %ymm8 + QUAD $0xfffff6cb1d6f7dc5 // vmovdqa $-2357(%rip), %ymm11 /* LCPI5_2(%rip) */ + QUAD $0xfffff6a30d6f7dc5 // vmovdqa $-2397(%rip), %ymm9 /* LCPI5_1(%rip) */ + QUAD $0xfffff67b156f7dc5 // vmovdqa $-2437(%rip), %ymm10 /* LCPI5_0(%rip) */ + WORD $0x0148; BYTE $0xc7 // addq %rax, %rdi + WORD $0x2949; BYTE $0xc3 // subq %rax, %r11 + WORD $0x0148; BYTE $0xc3 // addq %rax, %rbx + LONG $0x30f98348 // cmpq $48, %rcx + QUAD $0xfffff6c63d6ff9c5 // vmovdqa $-2362(%rip), %xmm7 /* LCPI5_3(%rip) */ + QUAD $0xfffff6ce2d6ff9c5 // vmovdqa $-2354(%rip), %xmm5 /* LCPI5_4(%rip) */ + QUAD $0xfffff6d6256ff9c5 // vmovdqa $-2346(%rip), %xmm4 /* LCPI5_5(%rip) */ + LONG $0xf676c9c5 // vpcmpeqd %xmm6, %xmm6, %xmm6 + LONG $0x00418d0f; WORD $0x0000 // jge LBB5_106, $65(%rip) + LONG $0xfffe30e9; BYTE $0xff // jmp LBB5_95, $-464(%rip) + +LBB5_105: + WORD $0xf8c5; BYTE $0x77 // vzeroupper + LONG $0x763d41c4; BYTE $0xc0 // vpcmpeqd %ymm8, %ymm8, %ymm8 + QUAD $0xfffff6771d6f7dc5 // vmovdqa $-2441(%rip), %ymm11 /* LCPI5_2(%rip) */ + QUAD $0xfffff64f0d6f7dc5 // vmovdqa $-2481(%rip), %ymm9 /* LCPI5_1(%rip) */ + QUAD $0xfffff627156f7dc5 // vmovdqa $-2521(%rip), %ymm10 /* LCPI5_0(%rip) */ + QUAD $0xfffff67f3d6ff9c5 // vmovdqa $-2433(%rip), %xmm7 /* LCPI5_3(%rip) */ + QUAD $0xfffff6872d6ff9c5 // vmovdqa $-2425(%rip), %xmm5 /* LCPI5_4(%rip) */ + QUAD $0xfffff68f256ff9c5 // vmovdqa $-2417(%rip), %xmm4 /* LCPI5_5(%rip) */ + LONG $0xf676c9c5 // vpcmpeqd %xmm6, %xmm6, %xmm6 + +LBB5_106: + LONG $0x000010b9; BYTE $0x00 // movl $16, %ecx + WORD $0xc031 // xorl %eax, %eax + LONG $0x90909090 // .p2align 4, 0x90 + +LBB5_107: + LONG $0x046ffac5; BYTE $0x07 // vmovdqu (%rdi,%rax), %xmm0 + LONG $0xc864c1c5 // vpcmpgtb %xmm0, %xmm7, %xmm1 + LONG $0xd574f9c5 // vpcmpeqb %xmm5, %xmm0, %xmm2 + LONG $0xdc74f9c5 // vpcmpeqb %xmm4, %xmm0, %xmm3 + LONG $0xd2ebe1c5 // vpor %xmm2, %xmm3, %xmm2 + LONG $0x047ffac5; BYTE $0x03 // vmovdqu %xmm0, (%rbx,%rax) + LONG $0xc664f9c5 // vpcmpgtb %xmm6, %xmm0, %xmm0 + LONG $0xc0dbf1c5 // vpand %xmm0, %xmm1, %xmm0 + LONG $0xc0ebe9c5 // vpor %xmm0, %xmm2, %xmm0 + LONG $0xf0d7f9c5 // vpmovmskb %xmm0, %esi + WORD $0x8566; BYTE $0xf6 // testw %si, %si + LONG $0x002f850f; WORD $0x0000 // jne LBB5_110, $47(%rip) + LONG $0x10c08348 // addq $16, %rax + LONG $0x0b748d49; BYTE $0xf0 // leaq $-16(%r11,%rcx), %rsi + LONG $0xf0c18348 // addq $-16, %rcx + LONG $0x1ffe8348 // cmpq $31, %rsi + LONG $0xffb68f0f; WORD $0xffff // jg LBB5_107, $-74(%rip) + WORD $0x0148; BYTE $0xc7 // addq %rax, %rdi + WORD $0x2949; BYTE $0xc3 // subq %rax, %r11 + WORD $0x0148; BYTE $0xc3 // addq %rax, %rbx + LONG $0x08fb8349 // cmpq $8, %r11 + LONG $0xfd968d0f; WORD $0xffff // jge LBB5_96, $-618(%rip) + LONG $0xfffe16e9; BYTE $0xff // jmp LBB5_99, $-490(%rip) -LBB8_113: - WORD $0xb60f; BYTE $0xc0 // movzbl %al, %eax +LBB5_110: + WORD $0xb70f; BYTE $0xce // movzwl %si, %ecx + WORD $0xbc0f; BYTE $0xc9 // bsfl %ecx, %ecx + LONG $0x000003e9; BYTE $0x00 // jmp LBB5_112, $3(%rip) -LBB8_114: - WORD $0xbc0f; BYTE $0xc0 // bsfl %eax, %eax +LBB5_111: + WORD $0xbc0f; BYTE $0xce // bsfl %esi, %ecx -LBB8_115: +LBB5_112: + WORD $0x0148; BYTE $0xcf // addq %rcx, %rdi WORD $0x0148; BYTE $0xc7 // addq %rax, %rdi - WORD $0x2948; BYTE $0xc6 // subq %rax, %rsi + WORD $0x2949; BYTE $0xcb // subq %rcx, %r11 + WORD $0x2949; BYTE $0xc3 // subq %rax, %r11 + WORD $0x0148; BYTE $0xcb // addq %rcx, %rbx + +LBB5_113: WORD $0x0148; BYTE $0xc3 // addq %rax, %rbx -LBB8_116: - WORD $0xb60f; BYTE $0x07 // movzbl (%rdi), %eax - LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 +LBB5_114: + WORD $0x078a // movb (%rdi), %al + QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90 -LBB8_117: +LBB5_115: WORD $0x8948; BYTE $0xd9 // movq %rbx, %rcx WORD $0xb60f; BYTE $0xc0 // movzbl %al, %eax LONG $0x04e0c148 // shlq $4, %rax @@ -2366,53 +2131,52 @@ LBB8_117: LONG $0x00448b49; BYTE $0x08 // movq $8(%r8,%rax), %rax WORD $0x8948; BYTE $0x01 // movq %rax, (%rcx) WORD $0x0148; BYTE $0xcb // addq %rcx, %rbx - LONG $0x02fe8348 // cmpq $2, %rsi - LONG $0x003a8c0f; WORD $0x0000 // jl LBB8_120, $58(%rip) - WORD $0xff48; BYTE $0xce // decq %rsi + LONG $0x02fb8349 // cmpq $2, %r11 + LONG $0x00418c0f; WORD $0x0000 // jl LBB5_119, $65(%rip) + WORD $0xff49; BYTE $0xcb // decq %r11 LONG $0x0147b60f // movzbl $1(%rdi), %eax WORD $0xff48; BYTE $0xc7 // incq %rdi LONG $0x083c8042; BYTE $0x00 // cmpb $0, (%rax,%r9) - LONG $0xffc8850f; WORD $0xffff // jne LBB8_117, $-56(%rip) - LONG $0xfffd6be9; BYTE $0xff // jmp LBB8_94, $-661(%rip) + LONG $0xffc8850f; WORD $0xffff // jne LBB5_115, $-56(%rip) + LONG $0xfffd12e9; BYTE $0xff // jmp LBB5_89, $-750(%rip) -LBB8_119: - WORD $0xb60f; BYTE $0xc0 // movzbl %al, %eax +LBB5_117: WORD $0xbc0f; BYTE $0xc0 // bsfl %eax, %eax - LONG $0x04488d48 // leaq $4(%rax), %rcx WORD $0x0148; BYTE $0xc7 // addq %rax, %rdi - LONG $0x04c78348 // addq $4, %rdi - WORD $0x2948; BYTE $0xce // subq %rcx, %rsi - WORD $0x0148; BYTE $0xc3 // addq %rax, %rbx - LONG $0x04c38348 // addq $4, %rbx - LONG $0xffff9ae9; BYTE $0xff // jmp LBB8_116, $-102(%rip) + WORD $0x2949; BYTE $0xc3 // subq %rax, %r11 + LONG $0xffffa4e9; BYTE $0xff // jmp LBB5_113, $-92(%rip) + +LBB5_118: + WORD $0xbc0f; BYTE $0xc0 // bsfl %eax, %eax + LONG $0x04488d48 // leaq $4(%rax), %rcx + LONG $0x077c8d48; BYTE $0x04 // leaq $4(%rdi,%rax), %rdi + WORD $0x2949; BYTE $0xcb // subq %rcx, %r11 + LONG $0x035c8d48; BYTE $0x04 // leaq $4(%rbx,%rax), %rbx + LONG $0xffff8ee9; BYTE $0xff // jmp LBB5_114, $-114(%rip) -LBB8_120: +LBB5_119: WORD $0x2948; BYTE $0xd3 // subq %rdx, %rbx WORD $0x8949; BYTE $0x1f // movq %rbx, (%r15) - LONG $0x00002be9; BYTE $0x00 // jmp LBB8_124, $43(%rip) - -LBB8_121: - WORD $0x014d; BYTE $0xeb // addq %r13, %r11 - LONG $0xc0558b48 // movq $-64(%rbp), %rdx + LONG $0x00001de9; BYTE $0x00 // jmp LBB5_123, $29(%rip) -LBB8_122: - WORD $0x2949; BYTE $0xd1 // subq %rdx, %r9 - WORD $0x894d; BYTE $0x0f // movq %r9, (%r15) +LBB5_120: + WORD $0x2949; BYTE $0xd4 // subq %rdx, %r12 + WORD $0x894d; BYTE $0x27 // movq %r12, (%r15) WORD $0x2949; BYTE $0xfb // subq %rdi, %r11 - WORD $0x894d; BYTE $0xde // movq %r11, %r14 - LONG $0x000013e9; BYTE $0x00 // jmp LBB8_124, $19(%rip) - -LBB8_123: - LONG $0xc04d2b4c // subq $-64(%rbp), %r9 - WORD $0x894d; BYTE $0x0f // movq %r9, (%r15) - WORD $0x294c; BYTE $0xdf // subq %r11, %rdi - WORD $0xf749; BYTE $0xd5 // notq %r13 - WORD $0x0149; BYTE $0xfd // addq %rdi, %r13 - WORD $0x894d; BYTE $0xee // movq %r13, %r14 + LONG $0x00000ce9; BYTE $0x00 // jmp LBB5_122, $12(%rip) -LBB8_124: - WORD $0x894c; BYTE $0xf0 // movq %r14, %rax - LONG $0x18c48348 // addq $24, %rsp +LBB5_121: + WORD $0x2949; BYTE $0xd4 // subq %rdx, %r12 + WORD $0x894d; BYTE $0x27 // movq %r12, (%r15) + WORD $0xf749; BYTE $0xd3 // notq %r11 + WORD $0x0149; BYTE $0xfb // addq %rdi, %r11 + +LBB5_122: + WORD $0x894d; BYTE $0xda // movq %r11, %r10 + +LBB5_123: + WORD $0x894c; BYTE $0xd0 // movq %r10, %rax + LONG $0x08c48348 // addq $8, %rsp BYTE $0x5b // popq %rbx WORD $0x5c41 // popq %r12 WORD $0x5d41 // popq %r13 @@ -2422,1055 +2186,997 @@ LBB8_124: WORD $0xf8c5; BYTE $0x77 // vzeroupper BYTE $0xc3 // retq -LBB8_125: - LONG $0xc0458b48 // movq $-64(%rbp), %rax - WORD $0x014c; BYTE $0xe8 // addq %r13, %rax - WORD $0xf748; BYTE $0xd0 // notq %rax - WORD $0x014c; BYTE $0xc8 // addq %r9, %rax - WORD $0x8949; BYTE $0x07 // movq %rax, (%r15) - WORD $0x294c; BYTE $0xdf // subq %r11, %rdi - WORD $0x014c; BYTE $0xef // addq %r13, %rdi - WORD $0x8949; BYTE $0xfe // movq %rdi, %r14 - LONG $0xffffcde9; BYTE $0xff // jmp LBB8_124, $-51(%rip) - QUAD $0x0000000000000000; QUAD $0x0000000000000000; QUAD $0x0000000000000000; WORD $0x0000 // .p2align 5, 0x00 +LBB5_124: + WORD $0x2949; BYTE $0xd4 // subq %rdx, %r12 + WORD $0x894c; BYTE $0xf0 // movq %r14, %rax + WORD $0xf748; BYTE $0xd0 // notq %rax + WORD $0x014c; BYTE $0xe0 // addq %r12, %rax + WORD $0x8949; BYTE $0x07 // movq %rax, (%r15) + WORD $0x294c; BYTE $0xdf // subq %r11, %rdi + WORD $0x014c; BYTE $0xf7 // addq %r14, %rdi + WORD $0x8949; BYTE $0xfa // movq %rdi, %r10 + LONG $0xffffcee9; BYTE $0xff // jmp LBB5_123, $-50(%rip) + QUAD $0x0000000000000000; QUAD $0x0000000000000000; WORD $0x0000 // .p2align 5, 0x00 -LCPI9_0: +LCPI6_0: QUAD $0x5c5c5c5c5c5c5c5c; QUAD $0x5c5c5c5c5c5c5c5c // .space 16, '\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' QUAD $0x5c5c5c5c5c5c5c5c; QUAD $0x5c5c5c5c5c5c5c5c // .space 16, '\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' // .p2align 4, 0x00 -LCPI9_1: +LCPI6_1: QUAD $0x5c5c5c5c5c5c5c5c; QUAD $0x5c5c5c5c5c5c5c5c // .space 16, '\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' -LCPI9_2: - BYTE $0xf0 // .byte 240 - BYTE $0x80 // .byte 128 - BYTE $0x80 // .byte 128 - BYTE $0x80 // .byte 128 - BYTE $0x00 // .space 1, '\x00' - BYTE $0x00 // .space 1, '\x00' - BYTE $0x00 // .space 1, '\x00' - BYTE $0x00 // .space 1, '\x00' - BYTE $0x00 // .space 1, '\x00' - BYTE $0x00 // .space 1, '\x00' - BYTE $0x00 // .space 1, '\x00' - BYTE $0x00 // .space 1, '\x00' - BYTE $0x00 // .space 1, '\x00' - BYTE $0x00 // .space 1, '\x00' - BYTE $0x00 // .space 1, '\x00' - BYTE $0x00 // .space 1, '\x00' - // .p2align 4, 0x90 _unquote: - BYTE $0x55 // pushq %rbp - WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp - WORD $0x5741 // pushq %r15 - WORD $0x5641 // pushq %r14 - WORD $0x5541 // pushq %r13 - WORD $0x5441 // pushq %r12 - BYTE $0x53 // pushq %rbx - LONG $0x48ec8348 // subq $72, %rsp - WORD $0x8548; BYTE $0xf6 // testq %rsi, %rsi - LONG $0x070f840f; WORD $0x0000 // je LBB9_1, $1807(%rip) - LONG $0xd04d8948 // movq %rcx, $-48(%rbp) - WORD $0x894c; BYTE $0xc0 // movq %r8, %rax - LONG $0xa045894c // movq %r8, $-96(%rbp) - WORD $0x894d; BYTE $0xc2 // movq %r8, %r10 - LONG $0x01e28341 // andl $1, %r10d - LONG $0x1d058d4c; WORD $0x00f5; BYTE $0x00 // leaq $62749(%rip), %r8 /* __UnquoteTab(%rip) */ - QUAD $0xffffff850d6ffdc5 // vmovdqa $-123(%rip), %ymm1 /* LCPI9_0(%rip) */ - QUAD $0xffffff9d156ff9c5 // vmovdqa $-99(%rip), %xmm2 /* LCPI9_1(%rip) */ - WORD $0x8949; BYTE $0xff // movq %rdi, %r15 - WORD $0x8949; BYTE $0xf5 // movq %rsi, %r13 - WORD $0x8949; BYTE $0xd6 // movq %rdx, %r14 - LONG $0x00021fe9; BYTE $0x00 // jmp LBB9_3, $543(%rip) - QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5741 // pushq %r15 + WORD $0x5641 // pushq %r14 + WORD $0x5541 // pushq %r13 + WORD $0x5441 // pushq %r12 + BYTE $0x53 // pushq %rbx + LONG $0x18ec8348 // subq $24, %rsp + WORD $0x8949; BYTE $0xd3 // movq %rdx, %r11 + WORD $0x8548; BYTE $0xf6 // testq %rsi, %rsi + LONG $0x0029840f; WORD $0x0000 // je LBB6_2, $41(%rip) + LONG $0xd04d8948 // movq %rcx, $-48(%rbp) + WORD $0x8945; BYTE $0xc2 // movl %r8d, %r10d + LONG $0x01e28341 // andl $1, %r10d + QUAD $0xffffffa00d6ffdc5 // vmovdqa $-96(%rip), %ymm1 /* LCPI6_0(%rip) */ + QUAD $0xffffffb8156ff9c5 // vmovdqa $-72(%rip), %xmm2 /* LCPI6_1(%rip) */ + WORD $0x8949; BYTE $0xf9 // movq %rdi, %r9 + WORD $0x8949; BYTE $0xf5 // movq %rsi, %r13 + WORD $0x894c; BYTE $0xda // movq %r11, %rdx + LONG $0x000056e9; BYTE $0x00 // jmp LBB6_8, $86(%rip) + +LBB6_2: + WORD $0x3145; BYTE $0xed // xorl %r13d, %r13d + WORD $0x894c; BYTE $0xda // movq %r11, %rdx -LBB9_59: - LONG $0xfffc8141; WORD $0x0007; BYTE $0x00 // cmpl $2047, %r12d - LONG $0x0573860f; WORD $0x0000 // jbe LBB9_67, $1395(%rip) - QUAD $0xffff200024848d41 // leal $-57344(%r12), %eax - LONG $0xfff7ff3d; BYTE $0xff // cmpl $-2049, %eax - LONG $0x0520860f; WORD $0x0000 // jbe LBB9_70, $1312(%rip) - WORD $0x854d; BYTE $0xd2 // testq %r10, %r10 - LONG $0xc07d8948 // movq %rdi, $-64(%rbp) - LONG $0xb8758948 // movq %rsi, $-72(%rbp) - LONG $0x00dc850f; WORD $0x0000 // jne LBB9_62, $220(%rip) - LONG $0xb055894c // movq %r10, $-80(%rbp) - LONG $0xa8558948 // movq %rdx, $-88(%rbp) - LONG $0x06fd8349 // cmpq $6, %r13 - LONG $0x00f58c0f; WORD $0x0000 // jl LBB9_94, $245(%rip) - -LBB9_91: - LONG $0xfffc8141; WORD $0x00db; BYTE $0x00 // cmpl $56319, %r12d - LONG $0x00e8870f; WORD $0x0000 // ja LBB9_94, $232(%rip) - LONG $0x5c3f8041 // cmpb $92, (%r15) - LONG $0x00de850f; WORD $0x0000 // jne LBB9_94, $222(%rip) - LONG $0x017f8041; BYTE $0x75 // cmpb $117, $1(%r15) - LONG $0x00d3850f; WORD $0x0000 // jne LBB9_94, $211(%rip) - LONG $0x025f8b41 // movl $2(%r15), %ebx - WORD $0xdf89 // movl %ebx, %edi - WORD $0xf8c5; BYTE $0x77 // vzeroupper - LONG $0x0008ade8; BYTE $0x00 // callq _unhex16_is, $2221(%rip) - WORD $0xc084 // testb %al, %al - LONG $0x0798840f; WORD $0x0000 // je LBB9_100, $1944(%rip) - WORD $0xcb0f // bswapl %ebx - WORD $0xd889 // movl %ebx, %eax - WORD $0xd0f7 // notl %eax - WORD $0xe8c1; BYTE $0x04 // shrl $4, %eax - LONG $0x01010125; BYTE $0x01 // andl $16843009, %eax - WORD $0x048d; BYTE $0xc0 // leal (%rax,%rax,8), %eax - LONG $0x0f0fe381; WORD $0x0f0f // andl $252645135, %ebx - WORD $0xc301 // addl %eax, %ebx - WORD $0xd889 // movl %ebx, %eax - WORD $0xe8c1; BYTE $0x04 // shrl $4, %eax - WORD $0xd809 // orl %ebx, %eax - WORD $0xb60f; BYTE $0xc8 // movzbl %al, %ecx - WORD $0xe8c1; BYTE $0x08 // shrl $8, %eax - LONG $0x00ff0025; BYTE $0x00 // andl $65280, %eax - WORD $0x1c8d; BYTE $0x08 // leal (%rax,%rcx), %ebx - LONG $0x06c78349 // addq $6, %r15 - LONG $0xfac58349 // addq $-6, %r13 - WORD $0xc801 // addl %ecx, %eax - LONG $0xff200005; BYTE $0xff // addl $-57344, %eax - LONG $0xfffbff3d; BYTE $0xff // cmpl $-1025, %eax - LONG $0xc07d8b48 // movq $-64(%rbp), %rdi - LONG $0xa8558b48 // movq $-88(%rbp), %rdx - LONG $0xb8758b48 // movq $-72(%rbp), %rsi - LONG $0x20058d4c; WORD $0x00f4; BYTE $0x00 // leaq $62496(%rip), %r8 /* __UnquoteTab(%rip) */ - QUAD $0xfffffe880d6ffdc5 // vmovdqa $-376(%rip), %ymm1 /* LCPI9_0(%rip) */ - QUAD $0xfffffea0156ff9c5 // vmovdqa $-352(%rip), %xmm2 /* LCPI9_1(%rip) */ - LONG $0x0070870f; WORD $0x0000 // ja LBB9_110, $112(%rip) - LONG $0x06c74166; WORD $0xbfef // movw $-16401, (%r14) - LONG $0x0246c641; BYTE $0xbd // movb $-67, $2(%r14) - LONG $0x03c68349 // addq $3, %r14 - WORD $0x8941; BYTE $0xdc // movl %ebx, %r12d - LONG $0x0080fb81; WORD $0x0000 // cmpl $128, %ebx - LONG $0xb0558b4c // movq $-80(%rbp), %r10 - LONG $0xfef8830f; WORD $0xffff // jae LBB9_59, $-264(%rip) - LONG $0x0003f8e9; BYTE $0x00 // jmp LBB9_112, $1016(%rip) +LBB6_3: + WORD $0x014c; BYTE $0xea // addq %r13, %rdx + WORD $0x294c; BYTE $0xda // subq %r11, %rdx -LBB9_62: - WORD $0x854d; BYTE $0xed // testq %r13, %r13 - LONG $0x06d88e0f; WORD $0x0000 // jle LBB9_63, $1752(%rip) - LONG $0x5c3f8041 // cmpb $92, (%r15) - LONG $0x00c5850f; WORD $0x0000 // jne LBB9_96, $197(%rip) - WORD $0xff49; BYTE $0xcd // decq %r13 - WORD $0xff49; BYTE $0xc7 // incq %r15 - LONG $0xb055894c // movq %r10, $-80(%rbp) - LONG $0xa8558948 // movq %rdx, $-88(%rbp) - LONG $0x06fd8349 // cmpq $6, %r13 - LONG $0xff0b8d0f; WORD $0xffff // jge LBB9_91, $-245(%rip) - -LBB9_94: - LONG $0x02a045f6 // testb $2, $-96(%rbp) - LONG $0x0565840f; WORD $0x0000 // je LBB9_77, $1381(%rip) - LONG $0x06c74166; WORD $0xbfef // movw $-16401, (%r14) - LONG $0x0246c641; BYTE $0xbd // movb $-67, $2(%r14) - LONG $0x03c68349 // addq $3, %r14 - LONG $0x00005ae9; BYTE $0x00 // jmp LBB9_86, $90(%rip) - -LBB9_110: - WORD $0xd889 // movl %ebx, %eax - -LBB9_85: - LONG $0x0ae4c141 // shll $10, %r12d - WORD $0xc189 // movl %eax, %ecx - WORD $0x0144; BYTE $0xe1 // addl %r12d, %ecx - WORD $0x0144; BYTE $0xe0 // addl %r12d, %eax - LONG $0xa0240005; BYTE $0xfc // addl $-56613888, %eax - WORD $0xc289 // movl %eax, %edx - WORD $0xeac1; BYTE $0x12 // shrl $18, %edx - WORD $0xc689 // movl %eax, %esi - WORD $0xeec1; BYTE $0x0c // shrl $12, %esi - LONG $0x3fe68040 // andb $63, %sil - WORD $0xe8c1; BYTE $0x06 // shrl $6, %eax - LONG $0xc26ef9c5 // vmovd %edx, %xmm0 - LONG $0xd6b60f40 // movzbl %sil, %edx - LONG $0x2079e3c4; WORD $0x01c2 // vpinsrb $1, %edx, %xmm0, %xmm0 - WORD $0x3f24 // andb $63, %al - WORD $0xb60f; BYTE $0xc0 // movzbl %al, %eax - LONG $0x2079e3c4; WORD $0x02c0 // vpinsrb $2, %eax, %xmm0, %xmm0 - WORD $0xe180; BYTE $0x3f // andb $63, %cl - WORD $0xb60f; BYTE $0xc1 // movzbl %cl, %eax - LONG $0x2079e3c4; WORD $0x03c0 // vpinsrb $3, %eax, %xmm0, %xmm0 - QUAD $0xfffffde905ebf9c5 // vpor $-535(%rip), %xmm0, %xmm0 /* LCPI9_2(%rip) */ - LONG $0x7e79c1c4; BYTE $0x06 // vmovd %xmm0, (%r14) - LONG $0x04c68349 // addq $4, %r14 - -LBB9_86: - LONG $0xc07d8b48 // movq $-64(%rbp), %rdi - LONG $0xa8558b48 // movq $-88(%rbp), %rdx - LONG $0xb0558b4c // movq $-80(%rbp), %r10 - LONG $0xb8758b48 // movq $-72(%rbp), %rsi - LONG $0x29058d4c; WORD $0x00f3; BYTE $0x00 // leaq $62249(%rip), %r8 /* __UnquoteTab(%rip) */ - QUAD $0xfffffd910d6ffdc5 // vmovdqa $-623(%rip), %ymm1 /* LCPI9_0(%rip) */ - QUAD $0xfffffda9156ff9c5 // vmovdqa $-599(%rip), %xmm2 /* LCPI9_1(%rip) */ - WORD $0x854d; BYTE $0xed // testq %r13, %r13 - LONG $0x0030850f; WORD $0x0000 // jne LBB9_3, $48(%rip) - LONG $0x000622e9; BYTE $0x00 // jmp LBB9_115, $1570(%rip) - -LBB9_96: - LONG $0x02a045f6 // testb $2, $-96(%rbp) - LONG $0x0705840f; WORD $0x0000 // je LBB9_97, $1797(%rip) - LONG $0x06c74166; WORD $0xbfef // movw $-16401, (%r14) - LONG $0x0246c641; BYTE $0xbd // movb $-67, $2(%r14) - LONG $0x03c68349 // addq $3, %r14 - LONG $0xc07d8b48 // movq $-64(%rbp), %rdi - LONG $0xb8758b48 // movq $-72(%rbp), %rsi +LBB6_4: + WORD $0x8948; BYTE $0xd0 // movq %rdx, %rax + LONG $0x18c48348 // addq $24, %rsp + BYTE $0x5b // popq %rbx + WORD $0x5c41 // popq %r12 + WORD $0x5d41 // popq %r13 + WORD $0x5e41 // popq %r14 + WORD $0x5f41 // popq %r15 + BYTE $0x5d // popq %rbp + WORD $0xf8c5; BYTE $0x77 // vzeroupper + BYTE $0xc3 // retq + +LBB6_5: + LONG $0x214c8d4f; BYTE $0x04 // leaq $4(%r9,%r12), %r9 + WORD $0x8944; BYTE $0xf8 // movl %r15d, %eax + WORD $0xe8c1; BYTE $0x06 // shrl $6, %eax + WORD $0xc00c // orb $-64, %al + WORD $0x0288 // movb %al, (%rdx) + LONG $0x3fe78041 // andb $63, %r15b + LONG $0x80cf8041 // orb $-128, %r15b + LONG $0x017a8844 // movb %r15b, $1(%rdx) + LONG $0x02c28348 // addq $2, %rdx + QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90 + +LBB6_6: + WORD $0x894d; BYTE $0xf5 // movq %r14, %r13 + +LBB6_7: WORD $0x854d; BYTE $0xed // testq %r13, %r13 - LONG $0x05f8840f; WORD $0x0000 // je LBB9_115, $1528(%rip) - BYTE $0x90 // .p2align 4, 0x90 + LONG $0x0846840f; WORD $0x0000 // je LBB6_115, $2118(%rip) -LBB9_3: - LONG $0x5c3f8041 // cmpb $92, (%r15) - LONG $0x0016850f; WORD $0x0000 // jne LBB9_5, $22(%rip) - WORD $0x3145; BYTE $0xc9 // xorl %r9d, %r9d - LONG $0x00015ee9; BYTE $0x00 // jmp LBB9_23, $350(%rip) - QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 +LBB6_8: + LONG $0x5c398041 // cmpb $92, (%r9) + LONG $0x000a850f; WORD $0x0000 // jne LBB6_10, $10(%rip) + WORD $0xdb31 // xorl %ebx, %ebx + LONG $0x000143e9; BYTE $0x00 // jmp LBB6_24, $323(%rip) + WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 -LBB9_5: - WORD $0x894c; BYTE $0xeb // movq %r13, %rbx - WORD $0x894c; BYTE $0xf1 // movq %r14, %rcx - WORD $0x894d; BYTE $0xf9 // movq %r15, %r9 +LBB6_10: + WORD $0x894d; BYTE $0xef // movq %r13, %r15 + WORD $0x8948; BYTE $0xd0 // movq %rdx, %rax + WORD $0x894d; BYTE $0xce // movq %r9, %r14 LONG $0x20fd8349 // cmpq $32, %r13 - LONG $0x00458c0f; WORD $0x0000 // jl LBB9_11, $69(%rip) - WORD $0xc931 // xorl %ecx, %ecx - WORD $0x894c; BYTE $0xe8 // movq %r13, %rax - QUAD $0x9090909090909090 // .p2align 4, 0x90 + LONG $0x00408c0f; WORD $0x0000 // jl LBB6_14, $64(%rip) + WORD $0x894d; BYTE $0xce // movq %r9, %r14 + WORD $0x8948; BYTE $0xd0 // movq %rdx, %rax + WORD $0x894d; BYTE $0xec // movq %r13, %r12 + LONG $0x90909090 // .p2align 4, 0x90 -LBB9_7: - LONG $0x6f7ec1c4; WORD $0x0f04 // vmovdqu (%r15,%rcx), %ymm0 - LONG $0x7f7ec1c4; WORD $0x0e04 // vmovdqu %ymm0, (%r14,%rcx) +LBB6_12: + LONG $0x6f7ec1c4; BYTE $0x06 // vmovdqu (%r14), %ymm0 + LONG $0x007ffec5 // vmovdqu %ymm0, (%rax) LONG $0xc174fdc5 // vpcmpeqb %ymm1, %ymm0, %ymm0 LONG $0xd8d7fdc5 // vpmovmskb %ymm0, %ebx WORD $0xdb85 // testl %ebx, %ebx - LONG $0x00db850f; WORD $0x0000 // jne LBB9_8, $219(%rip) - LONG $0xe0588d48 // leaq $-32(%rax), %rbx - LONG $0x20c18348 // addq $32, %rcx - LONG $0x3ff88348 // cmpq $63, %rax - WORD $0x8948; BYTE $0xd8 // movq %rbx, %rax - LONG $0xffcf8f0f; WORD $0xffff // jg LBB9_7, $-49(%rip) - LONG $0x0f0c8d4d // leaq (%r15,%rcx), %r9 - WORD $0x014c; BYTE $0xf1 // addq %r14, %rcx + LONG $0x00c1850f; WORD $0x0000 // jne LBB6_22, $193(%rip) + LONG $0x20c68349 // addq $32, %r14 + LONG $0x20c08348 // addq $32, %rax + LONG $0x247c8d4d; BYTE $0xe0 // leaq $-32(%r12), %r15 + LONG $0x3ffc8349 // cmpq $63, %r12 + WORD $0x894d; BYTE $0xfc // movq %r15, %r12 + LONG $0xffcd8f0f; WORD $0xffff // jg LBB6_12, $-51(%rip) -LBB9_11: +LBB6_14: WORD $0xf8c5; BYTE $0x77 // vzeroupper - LONG $0x10fb8348 // cmpq $16, %rbx - LONG $0x00568c0f; WORD $0x0000 // jl LBB9_12, $86(%rip) - WORD $0x894d; BYTE $0xfb // movq %r15, %r11 - WORD $0x294d; BYTE $0xcb // subq %r9, %r11 - QUAD $0xfffffcbd0d6ffdc5 // vmovdqa $-835(%rip), %ymm1 /* LCPI9_0(%rip) */ - QUAD $0xfffffcd5156ff9c5 // vmovdqa $-811(%rip), %xmm2 /* LCPI9_1(%rip) */ - LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 + QUAD $0xfffffee2156ff9c5 // vmovdqa $-286(%rip), %xmm2 /* LCPI6_1(%rip) */ + LONG $0x10ff8349 // cmpq $16, %r15 + LONG $0x003b8c0f; WORD $0x0000 // jl LBB6_17, $59(%rip) + QUAD $0x9090909090909090 // .p2align 4, 0x90 -LBB9_18: - LONG $0x6f7ac1c4; BYTE $0x01 // vmovdqu (%r9), %xmm0 - LONG $0x017ffac5 // vmovdqu %xmm0, (%rcx) +LBB6_15: + LONG $0x6f7ac1c4; BYTE $0x06 // vmovdqu (%r14), %xmm0 + LONG $0x007ffac5 // vmovdqu %xmm0, (%rax) LONG $0xc274f9c5 // vpcmpeqb %xmm2, %xmm0, %xmm0 - LONG $0xc0d7f9c5 // vpmovmskb %xmm0, %eax - WORD $0xc085 // testl %eax, %eax - LONG $0x0094850f; WORD $0x0000 // jne LBB9_19, $148(%rip) - LONG $0x10c18349 // addq $16, %r9 - LONG $0x10c18348 // addq $16, %rcx - LONG $0xf0638d4c // leaq $-16(%rbx), %r12 - LONG $0xf0c38349 // addq $-16, %r11 - LONG $0x1ffb8348 // cmpq $31, %rbx - WORD $0x894c; BYTE $0xe3 // movq %r12, %rbx - LONG $0xffca870f; WORD $0xffff // ja LBB9_18, $-54(%rip) - LONG $0x000013e9; BYTE $0x00 // jmp LBB9_13, $19(%rip) - -LBB9_12: - WORD $0x8949; BYTE $0xdc // movq %rbx, %r12 - QUAD $0xfffffc6a0d6ffdc5 // vmovdqa $-918(%rip), %ymm1 /* LCPI9_0(%rip) */ - QUAD $0xfffffc82156ff9c5 // vmovdqa $-894(%rip), %xmm2 /* LCPI9_1(%rip) */ - -LBB9_13: - WORD $0x854d; BYTE $0xe4 // testq %r12, %r12 - LONG $0x03c8840f; WORD $0x0000 // je LBB9_116, $968(%rip) - WORD $0xc031 // xorl %eax, %eax - LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 - -LBB9_15: - LONG $0x1cb60f41; BYTE $0x01 // movzbl (%r9,%rax), %ebx - WORD $0xfb80; BYTE $0x5c // cmpb $92, %bl - LONG $0x0014840f; WORD $0x0000 // je LBB9_21, $20(%rip) - WORD $0x1c88; BYTE $0x01 // movb %bl, (%rcx,%rax) - WORD $0xff48; BYTE $0xc0 // incq %rax - WORD $0x3949; BYTE $0xc4 // cmpq %rax, %r12 - LONG $0xffe3850f; WORD $0xffff // jne LBB9_15, $-29(%rip) - LONG $0x00039de9; BYTE $0x00 // jmp LBB9_116, $925(%rip) + LONG $0xd8d7f9c5 // vpmovmskb %xmm0, %ebx + WORD $0x8566; BYTE $0xdb // testw %bx, %bx + LONG $0x008c850f; WORD $0x0000 // jne LBB6_23, $140(%rip) + LONG $0x10c68349 // addq $16, %r14 + LONG $0x10c08348 // addq $16, %rax + LONG $0xf04f8d49 // leaq $-16(%r15), %rcx + LONG $0x1fff8349 // cmpq $31, %r15 + WORD $0x8949; BYTE $0xcf // movq %rcx, %r15 + LONG $0xffcd8f0f; WORD $0xffff // jg LBB6_15, $-51(%rip) -LBB9_21: - WORD $0x294d; BYTE $0xf9 // subq %r15, %r9 - WORD $0x0149; BYTE $0xc1 // addq %rax, %r9 - LONG $0xfff98349 // cmpq $-1, %r9 - LONG $0x003e850f; WORD $0x0000 // jne LBB9_23, $62(%rip) - LONG $0x000388e9; BYTE $0x00 // jmp LBB9_116, $904(%rip) +LBB6_17: + WORD $0x854d; BYTE $0xff // testq %r15, %r15 + LONG $0xfef0840f; WORD $0xffff // je LBB6_3, $-272(%rip) + WORD $0xdb31 // xorl %ebx, %ebx + QUAD $0xfffffe6a0d6ffdc5 // vmovdqa $-406(%rip), %ymm1 /* LCPI6_0(%rip) */ + QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90 -LBB9_8: - LONG $0xcbbc0f44 // bsfl %ebx, %r9d - WORD $0x0149; BYTE $0xc9 // addq %rcx, %r9 - LONG $0xfff98349 // cmpq $-1, %r9 - LONG $0x0028850f; WORD $0x0000 // jne LBB9_23, $40(%rip) - LONG $0x000372e9; BYTE $0x00 // jmp LBB9_116, $882(%rip) +LBB6_19: + LONG $0x0cb60f41; BYTE $0x1e // movzbl (%r14,%rbx), %ecx + WORD $0xf980; BYTE $0x5c // cmpb $92, %cl + LONG $0x0014840f; WORD $0x0000 // je LBB6_21, $20(%rip) + WORD $0x0c88; BYTE $0x18 // movb %cl, (%rax,%rbx) + WORD $0xff48; BYTE $0xc3 // incq %rbx + WORD $0x3949; BYTE $0xdf // cmpq %rbx, %r15 + LONG $0xffe3850f; WORD $0xffff // jne LBB6_19, $-29(%rip) + LONG $0xfffebae9; BYTE $0xff // jmp LBB6_3, $-326(%rip) -LBB9_19: - LONG $0xc0bc0f66 // bsfw %ax, %ax - LONG $0xc8b70f44 // movzwl %ax, %r9d - WORD $0x294d; BYTE $0xd9 // subq %r11, %r9 - LONG $0xfff98349 // cmpq $-1, %r9 - LONG $0x035d840f; WORD $0x0000 // je LBB9_116, $861(%rip) - QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 +LBB6_21: + WORD $0x0149; BYTE $0xde // addq %rbx, %r14 + WORD $0x294d; BYTE $0xce // subq %r9, %r14 + WORD $0x894c; BYTE $0xf3 // movq %r14, %rbx + LONG $0xfffb8348 // cmpq $-1, %rbx + LONG $0x004b850f; WORD $0x0000 // jne LBB6_24, $75(%rip) + LONG $0xfffea2e9; BYTE $0xff // jmp LBB6_3, $-350(%rip) + +LBB6_22: + WORD $0x6348; BYTE $0xc3 // movslq %ebx, %rax + WORD $0x294d; BYTE $0xce // subq %r9, %r14 + LONG $0xd8bc0f48 // bsfq %rax, %rbx + WORD $0x014c; BYTE $0xf3 // addq %r14, %rbx + LONG $0xfffb8348 // cmpq $-1, %rbx + LONG $0x002f850f; WORD $0x0000 // jne LBB6_24, $47(%rip) + LONG $0xfffe86e9; BYTE $0xff // jmp LBB6_3, $-378(%rip) + +LBB6_23: + WORD $0xb70f; BYTE $0xc3 // movzwl %bx, %eax + WORD $0x294d; BYTE $0xce // subq %r9, %r14 + LONG $0xd8bc0f48 // bsfq %rax, %rbx + WORD $0x014c; BYTE $0xf3 // addq %r14, %rbx + QUAD $0xfffffdf50d6ffdc5 // vmovdqa $-523(%rip), %ymm1 /* LCPI6_0(%rip) */ + LONG $0xfffb8348 // cmpq $-1, %rbx + LONG $0xfe67840f; WORD $0xffff // je LBB6_3, $-409(%rip) + QUAD $0x9090909090909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 -LBB9_23: - LONG $0x02498d49 // leaq $2(%r9), %rcx - WORD $0x2949; BYTE $0xcd // subq %rcx, %r13 - LONG $0x0411880f; WORD $0x0000 // js LBB9_24, $1041(%rip) - WORD $0x014d; BYTE $0xcf // addq %r9, %r15 - LONG $0x02c78349 // addq $2, %r15 +LBB6_24: + LONG $0x02438d48 // leaq $2(%rbx), %rax + WORD $0x2949; BYTE $0xc5 // subq %rax, %r13 + LONG $0x06ed880f; WORD $0x0000 // js LBB6_116, $1773(%rip) + LONG $0x194c8d4d; BYTE $0x02 // leaq $2(%r9,%rbx), %r9 WORD $0x854d; BYTE $0xd2 // testq %r10, %r10 - LONG $0x0112850f; WORD $0x0000 // jne LBB9_26, $274(%rip) - -LBB9_37: - WORD $0x014d; BYTE $0xce // addq %r9, %r14 - LONG $0x47b60f41; BYTE $0xff // movzbl $-1(%r15), %eax - LONG $0x04b60f42; BYTE $0x00 // movzbl (%rax,%r8), %eax - LONG $0x0000ff3d; BYTE $0x00 // cmpl $255, %eax - LONG $0x002b840f; WORD $0x0000 // je LBB9_41, $43(%rip) - WORD $0xc085 // testl %eax, %eax - LONG $0x03f4840f; WORD $0x0000 // je LBB9_39, $1012(%rip) - WORD $0x8841; BYTE $0x06 // movb %al, (%r14) - -LBB9_113: - WORD $0xff49; BYTE $0xc6 // incq %r14 - WORD $0x854d; BYTE $0xed // testq %r13, %r13 - LONG $0xfe44850f; WORD $0xffff // jne LBB9_3, $-444(%rip) - LONG $0x000436e9; BYTE $0x00 // jmp LBB9_115, $1078(%rip) - QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + LONG $0x03d6850f; WORD $0x0000 // jne LBB6_67, $982(%rip) + +LBB6_26: + WORD $0x0148; BYTE $0xda // addq %rbx, %rdx + LONG $0x41b60f41; BYTE $0xff // movzbl $-1(%r9), %eax + LONG $0xe60d8d48; WORD $0x00ed; BYTE $0x00 // leaq $60902(%rip), %rcx /* __UnquoteTab(%rip) */ + WORD $0x048a; BYTE $0x08 // movb (%rax,%rcx), %al + WORD $0xff3c // cmpb $-1, %al + LONG $0x001b840f; WORD $0x0000 // je LBB6_29, $27(%rip) + WORD $0xc084 // testb %al, %al + LONG $0x058d840f; WORD $0x0000 // je LBB6_98, $1421(%rip) + WORD $0x0288 // movb %al, (%rdx) + WORD $0xff48; BYTE $0xc2 // incq %rdx + LONG $0xfffe5ce9; BYTE $0xff // jmp LBB6_7, $-420(%rip) + QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90 -LBB9_41: +LBB6_29: LONG $0x03fd8349 // cmpq $3, %r13 - LONG $0x03b4860f; WORD $0x0000 // jbe LBB9_24, $948(%rip) - WORD $0x8b41; BYTE $0x1f // movl (%r15), %ebx - WORD $0xd989 // movl %ebx, %ecx - WORD $0xd1f7 // notl %ecx - LONG $0xcfd0838d; WORD $0xcfcf // leal $-808464432(%rbx), %eax - LONG $0x8080e181; WORD $0x8080 // andl $-2139062144, %ecx - WORD $0xc185 // testl %eax, %ecx - LONG $0x02e5850f; WORD $0x0000 // jne LBB9_46, $741(%rip) - LONG $0x1919838d; WORD $0x1919 // leal $421075225(%rbx), %eax - WORD $0xd809 // orl %ebx, %eax + LONG $0x06a08e0f; WORD $0x0000 // jle LBB6_116, $1696(%rip) + WORD $0x8b45; BYTE $0x31 // movl (%r9), %r14d + WORD $0x8945; BYTE $0xf7 // movl %r14d, %r15d + WORD $0xf741; BYTE $0xd7 // notl %r15d + LONG $0xd0868d41; WORD $0xcfcf; BYTE $0xcf // leal $-808464432(%r14), %eax + LONG $0x80e78141; WORD $0x8080; BYTE $0x80 // andl $-2139062144, %r15d + WORD $0x8541; BYTE $0xc7 // testl %eax, %r15d + LONG $0x049c850f; WORD $0x0000 // jne LBB6_89, $1180(%rip) + LONG $0x19868d41; WORD $0x1919; BYTE $0x19 // leal $421075225(%r14), %eax + WORD $0x0944; BYTE $0xf0 // orl %r14d, %eax LONG $0x808080a9; BYTE $0x80 // testl $-2139062144, %eax - LONG $0x02d2850f; WORD $0x0000 // jne LBB9_46, $722(%rip) - WORD $0xd889 // movl %ebx, %eax - LONG $0x7f7f7f25; BYTE $0x7f // andl $2139062143, %eax - LONG $0xc0c0bb41; WORD $0xc0c0 // movl $-1061109568, %r11d - WORD $0x2941; BYTE $0xc3 // subl %eax, %r11d - LONG $0x46888d44; WORD $0x4646; BYTE $0x46 // leal $1179010630(%rax), %r9d - WORD $0x2141; BYTE $0xcb // andl %ecx, %r11d - WORD $0x8545; BYTE $0xcb // testl %r9d, %r11d - LONG $0x02af850f; WORD $0x0000 // jne LBB9_46, $687(%rip) - LONG $0xe0e0b941; WORD $0xe0e0 // movl $-522133280, %r9d - WORD $0x2941; BYTE $0xc1 // subl %eax, %r9d - LONG $0x39393905; BYTE $0x39 // addl $960051513, %eax - WORD $0x2144; BYTE $0xc9 // andl %r9d, %ecx - WORD $0xc185 // testl %eax, %ecx - LONG $0x0296850f; WORD $0x0000 // jne LBB9_46, $662(%rip) - WORD $0xcb0f // bswapl %ebx - WORD $0xd989 // movl %ebx, %ecx - WORD $0xd1f7 // notl %ecx - WORD $0xe9c1; BYTE $0x04 // shrl $4, %ecx - LONG $0x0101e181; WORD $0x0101 // andl $16843009, %ecx - WORD $0x0c8d; BYTE $0xc9 // leal (%rcx,%rcx,8), %ecx - LONG $0x0f0fe381; WORD $0x0f0f // andl $252645135, %ebx - WORD $0xcb01 // addl %ecx, %ebx - WORD $0xd989 // movl %ebx, %ecx - WORD $0xe9c1; BYTE $0x04 // shrl $4, %ecx - WORD $0xd909 // orl %ebx, %ecx - WORD $0xb60f; BYTE $0xd9 // movzbl %cl, %ebx - WORD $0xe9c1; BYTE $0x08 // shrl $8, %ecx - LONG $0xff00e181; WORD $0x0000 // andl $65280, %ecx - WORD $0xcb09 // orl %ecx, %ebx - LONG $0x044f8d4d // leaq $4(%r15), %r9 - LONG $0xfc4d8d49 // leaq $-4(%r13), %rcx - LONG $0x0080fb81; WORD $0x0000 // cmpl $128, %ebx - LONG $0x0068820f; WORD $0x0000 // jb LBB9_56, $104(%rip) - LONG $0x02a045f6 // testb $2, $-96(%rbp) - LONG $0x006c840f; WORD $0x0000 // je LBB9_65, $108(%rip) - WORD $0x894d; BYTE $0xcf // movq %r9, %r15 - WORD $0x8941; BYTE $0xdc // movl %ebx, %r12d - WORD $0x8949; BYTE $0xcd // movq %rcx, %r13 - LONG $0xfffb51e9; BYTE $0xff // jmp LBB9_59, $-1199(%rip) - -LBB9_26: - WORD $0x8545; BYTE $0xed // testl %r13d, %r13d - LONG $0x02e6840f; WORD $0x0000 // je LBB9_24, $742(%rip) - LONG $0xff7f8041; BYTE $0x5c // cmpb $92, $-1(%r15) - LONG $0x0307850f; WORD $0x0000 // jne LBB9_28, $775(%rip) - LONG $0x5c3f8041 // cmpb $92, (%r15) - LONG $0x0027850f; WORD $0x0000 // jne LBB9_36, $39(%rip) - LONG $0x01fd8341 // cmpl $1, %r13d - LONG $0x02c78e0f; WORD $0x0000 // jle LBB9_24, $711(%rip) - LONG $0x4fb60f41; BYTE $0x01 // movzbl $1(%r15), %ecx - WORD $0xf983; BYTE $0x22 // cmpl $34, %ecx - LONG $0x0009840f; WORD $0x0000 // je LBB9_35, $9(%rip) - WORD $0xf983; BYTE $0x5c // cmpl $92, %ecx - LONG $0x02f5850f; WORD $0x0000 // jne LBB9_34, $757(%rip) - -LBB9_35: - WORD $0xff49; BYTE $0xc7 // incq %r15 - WORD $0xff49; BYTE $0xcd // decq %r13 - -LBB9_36: - WORD $0xff49; BYTE $0xc7 // incq %r15 - WORD $0xff49; BYTE $0xcd // decq %r13 - LONG $0xfffe9ee9; BYTE $0xff // jmp LBB9_37, $-354(%rip) - -LBB9_56: - WORD $0x8949; BYTE $0xcd // movq %rcx, %r13 - WORD $0x894d; BYTE $0xcf // movq %r9, %r15 - -LBB9_112: - WORD $0x8841; BYTE $0x1e // movb %bl, (%r14) - LONG $0xfffeb3e9; BYTE $0xff // jmp LBB9_113, $-333(%rip) - -LBB9_65: - LONG $0x0800fb81; WORD $0x0000 // cmpl $2048, %ebx - LONG $0x005e820f; WORD $0x0000 // jb LBB9_66, $94(%rip) - LONG $0x2000838d; WORD $0xffff // leal $-57344(%rbx), %eax - LONG $0xfff8003d; BYTE $0xff // cmpl $-2048, %eax - LONG $0x007f830f; WORD $0x0000 // jae LBB9_71, $127(%rip) - WORD $0x8949; BYTE $0xcd // movq %rcx, %r13 - WORD $0x8941; BYTE $0xdc // movl %ebx, %r12d - WORD $0x894d; BYTE $0xcf // movq %r9, %r15 - QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 - -LBB9_70: - WORD $0x8944; BYTE $0xe0 // movl %r12d, %eax - WORD $0xe8c1; BYTE $0x0c // shrl $12, %eax - WORD $0xe00c // orb $-32, %al - WORD $0x8841; BYTE $0x06 // movb %al, (%r14) - WORD $0x8944; BYTE $0xe0 // movl %r12d, %eax - WORD $0xe8c1; BYTE $0x06 // shrl $6, %eax - WORD $0x3f24 // andb $63, %al - WORD $0x800c // orb $-128, %al - LONG $0x01468841 // movb %al, $1(%r14) - LONG $0x3fe48041 // andb $63, %r12b - LONG $0x80cc8041 // orb $-128, %r12b - LONG $0x02668845 // movb %r12b, $2(%r14) - LONG $0x03c68349 // addq $3, %r14 - WORD $0x854d; BYTE $0xed // testq %r13, %r13 - LONG $0xfc9e850f; WORD $0xffff // jne LBB9_3, $-866(%rip) - LONG $0x000290e9; BYTE $0x00 // jmp LBB9_115, $656(%rip) - -LBB9_66: - WORD $0x8949; BYTE $0xcd // movq %rcx, %r13 - WORD $0x8941; BYTE $0xdc // movl %ebx, %r12d - WORD $0x894d; BYTE $0xcf // movq %r9, %r15 - -LBB9_67: - WORD $0x8944; BYTE $0xe0 // movl %r12d, %eax - WORD $0xe8c1; BYTE $0x06 // shrl $6, %eax - WORD $0xc00c // orb $-64, %al - WORD $0x8841; BYTE $0x06 // movb %al, (%r14) - LONG $0x3fe48041 // andb $63, %r12b - LONG $0x80cc8041 // orb $-128, %r12b - LONG $0x01668845 // movb %r12b, $1(%r14) - LONG $0x02c68349 // addq $2, %r14 - WORD $0x854d; BYTE $0xed // testq %r13, %r13 - LONG $0xfc6c850f; WORD $0xffff // jne LBB9_3, $-916(%rip) - LONG $0x00025ee9; BYTE $0x00 // jmp LBB9_115, $606(%rip) - -LBB9_71: - WORD $0x8949; BYTE $0xdc // movq %rbx, %r12 - LONG $0x984d8948 // movq %rcx, $-104(%rbp) - LONG $0xc84d894c // movq %r9, $-56(%rbp) - LONG $0xb8758948 // movq %rsi, $-72(%rbp) - LONG $0xa8558948 // movq %rdx, $-88(%rbp) - LONG $0xc07d8948 // movq %rdi, $-64(%rbp) - LONG $0xb055894c // movq %r10, $-80(%rbp) - WORD $0x854d; BYTE $0xd2 // testq %r10, %r10 - LONG $0x00a4850f; WORD $0x0000 // jne LBB9_72, $164(%rip) - LONG $0x987d8348; BYTE $0x06 // cmpq $6, $-104(%rbp) - LONG $0x00cb820f; WORD $0x0000 // jb LBB9_76, $203(%rip) - -LBB9_78: - LONG $0xfffc8141; WORD $0x00db; BYTE $0x00 // cmpl $56319, %r12d - LONG $0x00be870f; WORD $0x0000 // ja LBB9_76, $190(%rip) - LONG $0xc8458b48 // movq $-56(%rbp), %rax - WORD $0x3880; BYTE $0x5c // cmpb $92, (%rax) - LONG $0x00b1850f; WORD $0x0000 // jne LBB9_76, $177(%rip) - LONG $0xc8458b48 // movq $-56(%rbp), %rax - LONG $0x75017880 // cmpb $117, $1(%rax) - LONG $0x00a3850f; WORD $0x0000 // jne LBB9_76, $163(%rip) - LONG $0xc8458b48 // movq $-56(%rbp), %rax - WORD $0x588b; BYTE $0x02 // movl $2(%rax), %ebx - WORD $0xdf89 // movl %ebx, %edi - WORD $0xf8c5; BYTE $0x77 // vzeroupper - LONG $0x00030fe8; BYTE $0x00 // callq _unhex16_is, $783(%rip) - WORD $0xc084 // testb %al, %al - LONG $0x01f6840f; WORD $0x0000 // je LBB9_82, $502(%rip) - WORD $0xcb0f // bswapl %ebx - WORD $0xd889 // movl %ebx, %eax - WORD $0xd0f7 // notl %eax + LONG $0x0487850f; WORD $0x0000 // jne LBB6_89, $1159(%rip) + WORD $0x8944; BYTE $0xf3 // movl %r14d, %ebx + LONG $0x7f7fe381; WORD $0x7f7f // andl $2139062143, %ebx + LONG $0xc0c0c0b8; BYTE $0xc0 // movl $-1061109568, %eax + WORD $0xd829 // subl %ebx, %eax + LONG $0x46468b8d; WORD $0x4646 // leal $1179010630(%rbx), %ecx + WORD $0x2144; BYTE $0xf8 // andl %r15d, %eax + WORD $0xc885 // testl %ecx, %eax + LONG $0x0466850f; WORD $0x0000 // jne LBB6_89, $1126(%rip) + LONG $0xe0e0e0b8; BYTE $0xe0 // movl $-522133280, %eax + WORD $0xd829 // subl %ebx, %eax + LONG $0x3939c381; WORD $0x3939 // addl $960051513, %ebx + WORD $0x2141; BYTE $0xc7 // andl %eax, %r15d + WORD $0x8541; BYTE $0xdf // testl %ebx, %r15d + LONG $0x044d850f; WORD $0x0000 // jne LBB6_89, $1101(%rip) + WORD $0x0f41; BYTE $0xce // bswapl %r14d + WORD $0x8944; BYTE $0xf0 // movl %r14d, %eax WORD $0xe8c1; BYTE $0x04 // shrl $4, %eax + WORD $0xd0f7 // notl %eax LONG $0x01010125; BYTE $0x01 // andl $16843009, %eax WORD $0x048d; BYTE $0xc0 // leal (%rax,%rax,8), %eax - LONG $0x0f0fe381; WORD $0x0f0f // andl $252645135, %ebx - WORD $0xc301 // addl %eax, %ebx - WORD $0xd889 // movl %ebx, %eax + LONG $0x0fe68141; WORD $0x0f0f; BYTE $0x0f // andl $252645135, %r14d + WORD $0x0141; BYTE $0xc6 // addl %eax, %r14d + WORD $0x8944; BYTE $0xf0 // movl %r14d, %eax WORD $0xe8c1; BYTE $0x04 // shrl $4, %eax - WORD $0xd809 // orl %ebx, %eax - WORD $0xb60f; BYTE $0xc8 // movzbl %al, %ecx + WORD $0x0944; BYTE $0xf0 // orl %r14d, %eax + LONG $0xf8b60f44 // movzbl %al, %r15d WORD $0xe8c1; BYTE $0x08 // shrl $8, %eax LONG $0x00ff0025; BYTE $0x00 // andl $65280, %eax - LONG $0xc8458348; BYTE $0x06 // addq $6, $-56(%rbp) - WORD $0x148d; BYTE $0x08 // leal (%rax,%rcx), %edx - LONG $0x2000c281; WORD $0xffff // addl $-57344, %edx - LONG $0xfc00fa81; WORD $0xffff // cmpl $-1024, %edx - LONG $0x029a820f; WORD $0x0000 // jb LBB9_98, $666(%rip) + WORD $0x0941; BYTE $0xc7 // orl %eax, %r15d + LONG $0xfc758d4d // leaq $-4(%r13), %r14 + LONG $0x80ff8141; WORD $0x0000; BYTE $0x00 // cmpl $128, %r15d + LONG $0x032f820f; WORD $0x0000 // jb LBB6_75, $815(%rip) + WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d + WORD $0x854d; BYTE $0xd2 // testq %r10, %r10 + LONG $0x0145850f; WORD $0x0000 // jne LBB6_49, $325(%rip) + +LBB6_36: + LONG $0x00ff8141; WORD $0x0008; BYTE $0x00 // cmpl $2048, %r15d + LONG $0xfd4f820f; WORD $0xffff // jb LBB6_5, $-689(%rip) + WORD $0x8944; BYTE $0xf8 // movl %r15d, %eax + LONG $0xfff80025; BYTE $0xff // andl $-2048, %eax + LONG $0x00d8003d; BYTE $0x00 // cmpl $55296, %eax + LONG $0x0285850f; WORD $0x0000 // jne LBB6_65, $645(%rip) + LONG $0xffff8141; WORD $0x00db; BYTE $0x00 // cmpl $56319, %r15d + LONG $0x0305870f; WORD $0x0000 // ja LBB6_77, $773(%rip) + LONG $0x06fe8349 // cmpq $6, %r14 + LONG $0x02fb8c0f; WORD $0x0000 // jl LBB6_77, $763(%rip) + LONG $0x217c8043; WORD $0x5c04 // cmpb $92, $4(%r9,%r12) + LONG $0x02ef850f; WORD $0x0000 // jne LBB6_77, $751(%rip) + LONG $0x217c8043; WORD $0x7505 // cmpb $117, $5(%r9,%r12) + LONG $0x02e3850f; WORD $0x0000 // jne LBB6_77, $739(%rip) + LONG $0x214c8b43; BYTE $0x06 // movl $6(%r9,%r12), %ecx + WORD $0xcb89 // movl %ecx, %ebx + WORD $0xd3f7 // notl %ebx + LONG $0xcfd0818d; WORD $0xcfcf // leal $-808464432(%rcx), %eax + LONG $0x8080e381; WORD $0x8080 // andl $-2139062144, %ebx + WORD $0x5d89; BYTE $0xcc // movl %ebx, $-52(%rbp) + WORD $0xc385 // testl %eax, %ebx + LONG $0x0464850f; WORD $0x0000 // jne LBB6_100, $1124(%rip) + LONG $0x1919818d; WORD $0x1919 // leal $421075225(%rcx), %eax + WORD $0xc809 // orl %ecx, %eax + LONG $0x808080a9; BYTE $0x80 // testl $-2139062144, %eax + LONG $0x0451850f; WORD $0x0000 // jne LBB6_100, $1105(%rip) + WORD $0xcb89 // movl %ecx, %ebx + LONG $0x7f7fe381; WORD $0x7f7f // andl $2139062143, %ebx + LONG $0xc0c0c0b8; BYTE $0xc0 // movl $-1061109568, %eax + WORD $0xd829 // subl %ebx, %eax + LONG $0xc04d8948 // movq %rcx, $-64(%rbp) + LONG $0x46468b8d; WORD $0x4646 // leal $1179010630(%rbx), %ecx + WORD $0x4523; BYTE $0xcc // andl $-52(%rbp), %eax + WORD $0xc885 // testl %ecx, %eax + LONG $0xc04d8b48 // movq $-64(%rbp), %rcx + LONG $0x0429850f; WORD $0x0000 // jne LBB6_100, $1065(%rip) + LONG $0xe0e0e0b8; BYTE $0xe0 // movl $-522133280, %eax + WORD $0xd829 // subl %ebx, %eax + WORD $0x4589; BYTE $0xc8 // movl %eax, $-56(%rbp) + LONG $0x3939c381; WORD $0x3939 // addl $960051513, %ebx + WORD $0x458b; BYTE $0xcc // movl $-52(%rbp), %eax + WORD $0x4523; BYTE $0xc8 // andl $-56(%rbp), %eax + WORD $0xd885 // testl %ebx, %eax + LONG $0x040b850f; WORD $0x0000 // jne LBB6_100, $1035(%rip) + WORD $0xc90f // bswapl %ecx + WORD $0xc889 // movl %ecx, %eax + WORD $0xe8c1; BYTE $0x04 // shrl $4, %eax + WORD $0xd0f7 // notl %eax + LONG $0x01010125; BYTE $0x01 // andl $16843009, %eax + WORD $0x048d; BYTE $0xc0 // leal (%rax,%rax,8), %eax + LONG $0x0f0fe181; WORD $0x0f0f // andl $252645135, %ecx + WORD $0xc101 // addl %eax, %ecx + WORD $0xc889 // movl %ecx, %eax + WORD $0xe8c1; BYTE $0x04 // shrl $4, %eax + WORD $0xc809 // orl %ecx, %eax + WORD $0xc189 // movl %eax, %ecx + WORD $0xe9c1; BYTE $0x08 // shrl $8, %ecx + LONG $0xff00e181; WORD $0x0000 // andl $65280, %ecx + WORD $0xb60f; BYTE $0xd8 // movzbl %al, %ebx + WORD $0xcb09 // orl %ecx, %ebx + LONG $0xfc000025; BYTE $0x00 // andl $16515072, %eax + LONG $0xdc00003d; BYTE $0x00 // cmpl $14417920, %eax + LONG $0x026f840f; WORD $0x0000 // je LBB6_83, $623(%rip) + LONG $0x02c0f641 // testb $2, %r8b + LONG $0x04fa840f; WORD $0x0000 // je LBB6_119, $1274(%rip) + LONG $0xfac68349 // addq $-6, %r14 + LONG $0xef02c766; BYTE $0xbf // movw $-16401, (%rdx) + LONG $0xbd0242c6 // movb $-67, $2(%rdx) + LONG $0x03c28348 // addq $3, %rdx + LONG $0x06c48349 // addq $6, %r12 + WORD $0x8941; BYTE $0xdf // movl %ebx, %r15d + WORD $0xfb83; BYTE $0x7f // cmpl $127, %ebx + LONG $0xfecd870f; WORD $0xffff // ja LBB6_36, $-307(%rip) + LONG $0x000158e9; BYTE $0x00 // jmp LBB6_64, $344(%rip) + QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB6_49: + LONG $0x00ff8141; WORD $0x0008; BYTE $0x00 // cmpl $2048, %r15d + LONG $0xfc0a820f; WORD $0xffff // jb LBB6_5, $-1014(%rip) + WORD $0x8944; BYTE $0xf8 // movl %r15d, %eax + LONG $0xfff80025; BYTE $0xff // andl $-2048, %eax + LONG $0x00d8003d; BYTE $0x00 // cmpl $55296, %eax + LONG $0x0140850f; WORD $0x0000 // jne LBB6_65, $320(%rip) + WORD $0x854d; BYTE $0xf6 // testq %r14, %r14 + LONG $0x04528e0f; WORD $0x0000 // jle LBB6_113, $1106(%rip) + LONG $0x217c8043; WORD $0x5c04 // cmpb $92, $4(%r9,%r12) + LONG $0x01e9850f; WORD $0x0000 // jne LBB6_81, $489(%rip) + LONG $0xffff8141; WORD $0x00db; BYTE $0x00 // cmpl $56319, %r15d + LONG $0x01b5870f; WORD $0x0000 // ja LBB6_78, $437(%rip) + LONG $0x07fe8349 // cmpq $7, %r14 + LONG $0x01ab8c0f; WORD $0x0000 // jl LBB6_78, $427(%rip) + LONG $0x217c8043; WORD $0x5c05 // cmpb $92, $5(%r9,%r12) + LONG $0x019f850f; WORD $0x0000 // jne LBB6_78, $415(%rip) + LONG $0x217c8043; WORD $0x7506 // cmpb $117, $6(%r9,%r12) + LONG $0x0193850f; WORD $0x0000 // jne LBB6_78, $403(%rip) + LONG $0x214c8b43; BYTE $0x07 // movl $7(%r9,%r12), %ecx + WORD $0xcb89 // movl %ecx, %ebx + WORD $0xd3f7 // notl %ebx + LONG $0xcfd0818d; WORD $0xcfcf // leal $-808464432(%rcx), %eax + LONG $0x8080e381; WORD $0x8080 // andl $-2139062144, %ebx + WORD $0x5d89; BYTE $0xcc // movl %ebx, $-52(%rbp) + WORD $0xc385 // testl %eax, %ebx + LONG $0x0314850f; WORD $0x0000 // jne LBB6_101, $788(%rip) + LONG $0x1919818d; WORD $0x1919 // leal $421075225(%rcx), %eax WORD $0xc809 // orl %ecx, %eax - LONG $0x986d8b4c // movq $-104(%rbp), %r13 - LONG $0xfac58349 // addq $-6, %r13 - LONG $0xc87d8b4c // movq $-56(%rbp), %r15 - LONG $0xfffae7e9; BYTE $0xff // jmp LBB9_85, $-1305(%rip) - -LBB9_72: - LONG $0x05fd8349 // cmpq $5, %r13 - LONG $0x0262820f; WORD $0x0000 // jb LBB9_87, $610(%rip) - LONG $0xc8458b48 // movq $-56(%rbp), %rax - WORD $0x3880; BYTE $0x5c // cmpb $92, (%rax) - LONG $0x0270850f; WORD $0x0000 // jne LBB9_98, $624(%rip) - LONG $0xfbc58349 // addq $-5, %r13 - LONG $0x05c78349 // addq $5, %r15 - LONG $0x986d894c // movq %r13, $-104(%rbp) - LONG $0xc87d894c // movq %r15, $-56(%rbp) - LONG $0x987d8348; BYTE $0x06 // cmpq $6, $-104(%rbp) - LONG $0xff35830f; WORD $0xffff // jae LBB9_78, $-203(%rip) - -LBB9_76: - LONG $0xc87d8b4c // movq $-56(%rbp), %r15 - -LBB9_77: - LONG $0xb0458b48 // movq $-80(%rbp), %rax - LONG $0xc0450348 // addq $-64(%rbp), %rax - WORD $0x2949; BYTE $0xc7 // subq %rax, %r15 - LONG $0xfcc78349 // addq $-4, %r15 - LONG $0xd0458b48 // movq $-48(%rbp), %rax - WORD $0x894c; BYTE $0x38 // movq %r15, (%rax) - LONG $0xfcc6c749; WORD $0xffff; BYTE $0xff // movq $-4, %r14 - LONG $0x00000ce9; BYTE $0x00 // jmp LBB9_117, $12(%rip) + LONG $0x808080a9; BYTE $0x80 // testl $-2139062144, %eax + LONG $0x0301850f; WORD $0x0000 // jne LBB6_101, $769(%rip) + WORD $0xcb89 // movl %ecx, %ebx + LONG $0x7f7fe381; WORD $0x7f7f // andl $2139062143, %ebx + LONG $0xc0c0c0b8; BYTE $0xc0 // movl $-1061109568, %eax + WORD $0xd829 // subl %ebx, %eax + LONG $0xc04d8948 // movq %rcx, $-64(%rbp) + LONG $0x46468b8d; WORD $0x4646 // leal $1179010630(%rbx), %ecx + WORD $0x4523; BYTE $0xcc // andl $-52(%rbp), %eax + WORD $0xc885 // testl %ecx, %eax + LONG $0xc04d8b48 // movq $-64(%rbp), %rcx + LONG $0x02d9850f; WORD $0x0000 // jne LBB6_101, $729(%rip) + LONG $0xe0e0e0b8; BYTE $0xe0 // movl $-522133280, %eax + WORD $0xd829 // subl %ebx, %eax + WORD $0x4589; BYTE $0xc8 // movl %eax, $-56(%rbp) + LONG $0x3939c381; WORD $0x3939 // addl $960051513, %ebx + WORD $0x458b; BYTE $0xcc // movl $-52(%rbp), %eax + WORD $0x4523; BYTE $0xc8 // andl $-56(%rbp), %eax + WORD $0xd885 // testl %ebx, %eax + LONG $0x02bb850f; WORD $0x0000 // jne LBB6_101, $699(%rip) + WORD $0xc90f // bswapl %ecx + WORD $0xc889 // movl %ecx, %eax + WORD $0xe8c1; BYTE $0x04 // shrl $4, %eax + WORD $0xd0f7 // notl %eax + LONG $0x01010125; BYTE $0x01 // andl $16843009, %eax + WORD $0x048d; BYTE $0xc0 // leal (%rax,%rax,8), %eax + LONG $0x0f0fe181; WORD $0x0f0f // andl $252645135, %ecx + WORD $0xc101 // addl %eax, %ecx + WORD $0xc889 // movl %ecx, %eax + WORD $0xe8c1; BYTE $0x04 // shrl $4, %eax + WORD $0xc809 // orl %ecx, %eax + WORD $0xc189 // movl %eax, %ecx + WORD $0xe9c1; BYTE $0x08 // shrl $8, %ecx + LONG $0xff00e181; WORD $0x0000 // andl $65280, %ecx + WORD $0xb60f; BYTE $0xd8 // movzbl %al, %ebx + WORD $0xcb09 // orl %ecx, %ebx + LONG $0xfc000025; BYTE $0x00 // andl $16515072, %eax + LONG $0xdc00003d; BYTE $0x00 // cmpl $14417920, %eax + LONG $0x0126840f; WORD $0x0000 // je LBB6_84, $294(%rip) + LONG $0x02c0f641 // testb $2, %r8b + LONG $0x03aa840f; WORD $0x0000 // je LBB6_120, $938(%rip) + LONG $0xf9c68349 // addq $-7, %r14 + LONG $0xef02c766; BYTE $0xbf // movw $-16401, (%rdx) + LONG $0xbd0242c6 // movb $-67, $2(%rdx) + LONG $0x03c28348 // addq $3, %rdx + LONG $0x07c48349 // addq $7, %r12 + WORD $0x8941; BYTE $0xdf // movl %ebx, %r15d + LONG $0x0080fb81; WORD $0x0000 // cmpl $128, %ebx + LONG $0xfeb5830f; WORD $0xffff // jae LBB6_49, $-331(%rip) + +LBB6_64: + LONG $0x214c8d4f; BYTE $0x04 // leaq $4(%r9,%r12), %r9 + WORD $0x8941; BYTE $0xdf // movl %ebx, %r15d + LONG $0x00008ae9; BYTE $0x00 // jmp LBB6_76, $138(%rip) + QUAD $0x9090909090909090 // .p2align 4, 0x90 + +LBB6_65: + LONG $0x214c8d4f; BYTE $0x04 // leaq $4(%r9,%r12), %r9 + WORD $0x8944; BYTE $0xf8 // movl %r15d, %eax + WORD $0xe8c1; BYTE $0x0c // shrl $12, %eax + WORD $0xe00c // orb $-32, %al + WORD $0x0288 // movb %al, (%rdx) + WORD $0x8944; BYTE $0xf8 // movl %r15d, %eax + WORD $0xe8c1; BYTE $0x06 // shrl $6, %eax + WORD $0x3f24 // andb $63, %al + WORD $0x800c // orb $-128, %al + WORD $0x4288; BYTE $0x01 // movb %al, $1(%rdx) + LONG $0x3fe78041 // andb $63, %r15b + LONG $0x80cf8041 // orb $-128, %r15b + LONG $0x027a8844 // movb %r15b, $2(%rdx) -LBB9_1: - WORD $0x3145; BYTE $0xed // xorl %r13d, %r13d - WORD $0x8949; BYTE $0xd6 // movq %rdx, %r14 +LBB6_66: + LONG $0x03c28348 // addq $3, %rdx + LONG $0xfffaafe9; BYTE $0xff // jmp LBB6_6, $-1361(%rip) -LBB9_116: - WORD $0x014d; BYTE $0xee // addq %r13, %r14 - WORD $0x2949; BYTE $0xd6 // subq %rdx, %r14 +LBB6_67: + WORD $0x8545; BYTE $0xed // testl %r13d, %r13d + LONG $0x0300840f; WORD $0x0000 // je LBB6_116, $768(%rip) + LONG $0xff798041; BYTE $0x5c // cmpb $92, $-1(%r9) + LONG $0x01de850f; WORD $0x0000 // jne LBB6_99, $478(%rip) + LONG $0x5c398041 // cmpb $92, (%r9) + LONG $0x0024850f; WORD $0x0000 // jne LBB6_74, $36(%rip) + LONG $0x01fd8341 // cmpl $1, %r13d + LONG $0x02e18e0f; WORD $0x0000 // jle LBB6_116, $737(%rip) + LONG $0x01418a41 // movb $1(%r9), %al + WORD $0x223c // cmpb $34, %al + LONG $0x0008840f; WORD $0x0000 // je LBB6_73, $8(%rip) + WORD $0x5c3c // cmpb $92, %al + LONG $0x0295850f; WORD $0x0000 // jne LBB6_111, $661(%rip) -LBB9_117: - WORD $0x894c; BYTE $0xf0 // movq %r14, %rax - LONG $0x48c48348 // addq $72, %rsp - BYTE $0x5b // popq %rbx - WORD $0x5c41 // popq %r12 - WORD $0x5d41 // popq %r13 - WORD $0x5e41 // popq %r14 - WORD $0x5f41 // popq %r15 - BYTE $0x5d // popq %rbp - WORD $0xf8c5; BYTE $0x77 // vzeroupper - BYTE $0xc3 // retq +LBB6_73: + WORD $0xff49; BYTE $0xc1 // incq %r9 + WORD $0xff49; BYTE $0xcd // decq %r13 -LBB9_46: - WORD $0x894c; BYTE $0xf8 // movq %r15, %rax +LBB6_74: + WORD $0xff49; BYTE $0xc1 // incq %r9 + WORD $0xff49; BYTE $0xcd // decq %r13 + LONG $0xfffbdde9; BYTE $0xff // jmp LBB6_26, $-1059(%rip) + +LBB6_75: + LONG $0x04c18349 // addq $4, %r9 + +LBB6_76: + WORD $0x8844; BYTE $0x3a // movb %r15b, (%rdx) + WORD $0xff48; BYTE $0xc2 // incq %rdx + LONG $0xfffa53e9; BYTE $0xff // jmp LBB6_6, $-1453(%rip) + +LBB6_77: + LONG $0x214c8d4f; BYTE $0x04 // leaq $4(%r9,%r12), %r9 + LONG $0x00000fe9; BYTE $0x00 // jmp LBB6_79, $15(%rip) + +LBB6_78: + LONG $0x214c8d4f; BYTE $0x05 // leaq $5(%r9,%r12), %r9 + WORD $0x294d; BYTE $0xe5 // subq %r12, %r13 + LONG $0xfbc58349 // addq $-5, %r13 + WORD $0x894d; BYTE $0xee // movq %r13, %r14 + +LBB6_79: + LONG $0x02c0f641 // testb $2, %r8b + LONG $0x02e0840f; WORD $0x0000 // je LBB6_122, $736(%rip) + +LBB6_80: + LONG $0xef02c766; BYTE $0xbf // movw $-16401, (%rdx) + LONG $0xbd0242c6 // movb $-67, $2(%rdx) + LONG $0xffff6ae9; BYTE $0xff // jmp LBB6_66, $-150(%rip) + +LBB6_81: + LONG $0x02c0f641 // testb $2, %r8b + LONG $0x02d5840f; WORD $0x0000 // je LBB6_123, $725(%rip) + LONG $0x214c8d4f; BYTE $0x04 // leaq $4(%r9,%r12), %r9 + LONG $0xffffdee9; BYTE $0xff // jmp LBB6_80, $-34(%rip) + +LBB6_83: + LONG $0x214c8d4f; BYTE $0x0a // leaq $10(%r9,%r12), %r9 + WORD $0x294d; BYTE $0xe5 // subq %r12, %r13 + LONG $0xf6c58349 // addq $-10, %r13 + LONG $0x00000ce9; BYTE $0x00 // jmp LBB6_85, $12(%rip) + +LBB6_84: + LONG $0x214c8d4f; BYTE $0x0b // leaq $11(%r9,%r12), %r9 + WORD $0x294d; BYTE $0xe5 // subq %r12, %r13 + LONG $0xf5c58349 // addq $-11, %r13 + +LBB6_85: + LONG $0x0ae7c141 // shll $10, %r15d + QUAD $0xfca024001f9c8d41 // leal $-56613888(%r15,%rbx), %ebx + LONG $0x0000fb81; WORD $0x0011 // cmpl $1114112, %ebx + LONG $0x001c820f; WORD $0x0000 // jb LBB6_88, $28(%rip) + LONG $0x02c0f641 // testb $2, %r8b + LONG $0x023c840f; WORD $0x0000 // je LBB6_117, $572(%rip) + LONG $0xef02c766; BYTE $0xbf // movw $-16401, (%rdx) + LONG $0xbd0242c6 // movb $-67, $2(%rdx) + LONG $0x03c28348 // addq $3, %rdx + LONG $0xfff9c0e9; BYTE $0xff // jmp LBB6_7, $-1600(%rip) + +LBB6_88: + WORD $0xd889 // movl %ebx, %eax + WORD $0xe8c1; BYTE $0x12 // shrl $18, %eax + WORD $0xf00c // orb $-16, %al + WORD $0x0288 // movb %al, (%rdx) + WORD $0xd889 // movl %ebx, %eax + WORD $0xe8c1; BYTE $0x0c // shrl $12, %eax + WORD $0x3f24 // andb $63, %al + WORD $0x800c // orb $-128, %al + WORD $0x4288; BYTE $0x01 // movb %al, $1(%rdx) + WORD $0xd889 // movl %ebx, %eax + WORD $0xe8c1; BYTE $0x06 // shrl $6, %eax + WORD $0x3f24 // andb $63, %al + WORD $0x800c // orb $-128, %al + WORD $0x4288; BYTE $0x02 // movb %al, $2(%rdx) + WORD $0xe380; BYTE $0x3f // andb $63, %bl + WORD $0xcb80; BYTE $0x80 // orb $-128, %bl + WORD $0x5a88; BYTE $0x03 // movb %bl, $3(%rdx) + LONG $0x04c28348 // addq $4, %rdx + LONG $0xfff98de9; BYTE $0xff // jmp LBB6_7, $-1651(%rip) + +LBB6_89: + WORD $0x894c; BYTE $0xc8 // movq %r9, %rax WORD $0x2948; BYTE $0xf8 // subq %rdi, %rax - LONG $0xd0758b48 // movq $-48(%rbp), %rsi - WORD $0x8948; BYTE $0x06 // movq %rax, (%rsi) - LONG $0x0fb60f41 // movzbl (%r15), %ecx - WORD $0x518d; BYTE $0xc6 // leal $-58(%rcx), %edx - LONG $0xfec6c749; WORD $0xffff; BYTE $0xff // movq $-2, %r14 - WORD $0xfa80; BYTE $0xf5 // cmpb $-11, %dl - LONG $0x000f870f; WORD $0x0000 // ja LBB9_48, $15(%rip) + LONG $0xd07d8b48 // movq $-48(%rbp), %rdi + WORD $0x8948; BYTE $0x07 // movq %rax, (%rdi) + WORD $0x8a41; BYTE $0x09 // movb (%r9), %cl + WORD $0x718d; BYTE $0xd0 // leal $-48(%rcx), %esi + LONG $0xfec2c748; WORD $0xffff; BYTE $0xff // movq $-2, %rdx + LONG $0x0afe8040 // cmpb $10, %sil + LONG $0x000f820f; WORD $0x0000 // jb LBB6_91, $15(%rip) WORD $0xe180; BYTE $0xdf // andb $-33, %cl - WORD $0xc180; BYTE $0xb9 // addb $-71, %cl - WORD $0xf980; BYTE $0xfa // cmpb $-6, %cl - LONG $0xffb8820f; WORD $0xffff // jb LBB9_117, $-72(%rip) + WORD $0xc180; BYTE $0xbf // addb $-65, %cl + WORD $0xf980; BYTE $0x05 // cmpb $5, %cl + LONG $0xf919870f; WORD $0xffff // ja LBB6_4, $-1767(%rip) -LBB9_48: +LBB6_91: LONG $0x01488d48 // leaq $1(%rax), %rcx - WORD $0x8948; BYTE $0x0e // movq %rcx, (%rsi) - LONG $0x4fb60f41; BYTE $0x01 // movzbl $1(%r15), %ecx - WORD $0x518d; BYTE $0xc6 // leal $-58(%rcx), %edx - WORD $0xfa80; BYTE $0xf5 // cmpb $-11, %dl - LONG $0x000f870f; WORD $0x0000 // ja LBB9_50, $15(%rip) + WORD $0x8948; BYTE $0x0f // movq %rcx, (%rdi) + LONG $0x01498a41 // movb $1(%r9), %cl + WORD $0x718d; BYTE $0xd0 // leal $-48(%rcx), %esi + LONG $0x0afe8040 // cmpb $10, %sil + LONG $0x000f820f; WORD $0x0000 // jb LBB6_93, $15(%rip) WORD $0xe180; BYTE $0xdf // andb $-33, %cl - WORD $0xc180; BYTE $0xb9 // addb $-71, %cl - WORD $0xf980; BYTE $0xfa // cmpb $-6, %cl - LONG $0xff91820f; WORD $0xffff // jb LBB9_117, $-111(%rip) + WORD $0xc180; BYTE $0xbf // addb $-65, %cl + WORD $0xf980; BYTE $0x05 // cmpb $5, %cl + LONG $0xf8f2870f; WORD $0xffff // ja LBB6_4, $-1806(%rip) -LBB9_50: +LBB6_93: LONG $0x02488d48 // leaq $2(%rax), %rcx - WORD $0x8948; BYTE $0x0e // movq %rcx, (%rsi) - LONG $0x4fb60f41; BYTE $0x02 // movzbl $2(%r15), %ecx - WORD $0x518d; BYTE $0xc6 // leal $-58(%rcx), %edx - WORD $0xfa80; BYTE $0xf5 // cmpb $-11, %dl - LONG $0x000f870f; WORD $0x0000 // ja LBB9_52, $15(%rip) + WORD $0x8948; BYTE $0x0f // movq %rcx, (%rdi) + LONG $0x02498a41 // movb $2(%r9), %cl + WORD $0x718d; BYTE $0xd0 // leal $-48(%rcx), %esi + LONG $0x0afe8040 // cmpb $10, %sil + LONG $0x000f820f; WORD $0x0000 // jb LBB6_95, $15(%rip) WORD $0xe180; BYTE $0xdf // andb $-33, %cl - WORD $0xc180; BYTE $0xb9 // addb $-71, %cl - WORD $0xf980; BYTE $0xfa // cmpb $-6, %cl - LONG $0xff6a820f; WORD $0xffff // jb LBB9_117, $-150(%rip) + WORD $0xc180; BYTE $0xbf // addb $-65, %cl + WORD $0xf980; BYTE $0x05 // cmpb $5, %cl + LONG $0xf8cb870f; WORD $0xffff // ja LBB6_4, $-1845(%rip) -LBB9_52: +LBB6_95: LONG $0x03488d48 // leaq $3(%rax), %rcx - WORD $0x8948; BYTE $0x0e // movq %rcx, (%rsi) - LONG $0x4fb60f41; BYTE $0x03 // movzbl $3(%r15), %ecx - WORD $0x518d; BYTE $0xc6 // leal $-58(%rcx), %edx - WORD $0xfa80; BYTE $0xf5 // cmpb $-11, %dl - LONG $0x000f870f; WORD $0x0000 // ja LBB9_54, $15(%rip) + WORD $0x8948; BYTE $0x0f // movq %rcx, (%rdi) + LONG $0x03498a41 // movb $3(%r9), %cl + WORD $0x718d; BYTE $0xd0 // leal $-48(%rcx), %esi + LONG $0x0afe8040 // cmpb $10, %sil + LONG $0x000f820f; WORD $0x0000 // jb LBB6_97, $15(%rip) WORD $0xe180; BYTE $0xdf // andb $-33, %cl - WORD $0xc180; BYTE $0xb9 // addb $-71, %cl - WORD $0xf980; BYTE $0xfa // cmpb $-6, %cl - LONG $0xff43820f; WORD $0xffff // jb LBB9_117, $-189(%rip) + WORD $0xc180; BYTE $0xbf // addb $-65, %cl + WORD $0xf980; BYTE $0x05 // cmpb $5, %cl + LONG $0xf8a4870f; WORD $0xffff // ja LBB6_4, $-1884(%rip) -LBB9_54: +LBB6_97: LONG $0x04c08348 // addq $4, %rax - WORD $0x8948; BYTE $0x06 // movq %rax, (%rsi) - LONG $0xffff37e9; BYTE $0xff // jmp LBB9_117, $-201(%rip) + WORD $0x8948; BYTE $0x07 // movq %rax, (%rdi) + LONG $0xfff898e9; BYTE $0xff // jmp LBB6_4, $-1896(%rip) -LBB9_24: - LONG $0xd0458b48 // movq $-48(%rbp), %rax - WORD $0x8948; BYTE $0x30 // movq %rsi, (%rax) - LONG $0xffc6c749; WORD $0xffff; BYTE $0xff // movq $-1, %r14 - LONG $0xffff24e9; BYTE $0xff // jmp LBB9_117, $-220(%rip) - -LBB9_39: +LBB6_98: WORD $0xf748; BYTE $0xd7 // notq %rdi - WORD $0x0149; BYTE $0xff // addq %rdi, %r15 + WORD $0x0149; BYTE $0xf9 // addq %rdi, %r9 LONG $0xd0458b48 // movq $-48(%rbp), %rax - WORD $0x894c; BYTE $0x38 // movq %r15, (%rax) - LONG $0xfdc6c749; WORD $0xffff; BYTE $0xff // movq $-3, %r14 - LONG $0xffff0be9; BYTE $0xff // jmp LBB9_117, $-245(%rip) + WORD $0x894c; BYTE $0x08 // movq %r9, (%rax) + LONG $0xfdc2c748; WORD $0xffff; BYTE $0xff // movq $-3, %rdx + LONG $0xfff87fe9; BYTE $0xff // jmp LBB6_4, $-1921(%rip) -LBB9_28: - WORD $0xf748; BYTE $0xd7 // notq %rdi - WORD $0x0149; BYTE $0xff // addq %rdi, %r15 +LBB6_99: + WORD $0xf748; BYTE $0xd7 // notq %rdi + WORD $0x0149; BYTE $0xf9 // addq %rdi, %r9 + LONG $0x0000dae9; BYTE $0x00 // jmp LBB6_112, $218(%rip) -LBB9_29: - LONG $0xd0458b48 // movq $-48(%rbp), %rax - WORD $0x894c; BYTE $0x38 // movq %r15, (%rax) - LONG $0xfec6c749; WORD $0xffff; BYTE $0xff // movq $-2, %r14 - LONG $0xfffef2e9; BYTE $0xff // jmp LBB9_117, $-270(%rip) +LBB6_100: + LONG $0x21748d4b; BYTE $0x04 // leaq $4(%r9,%r12), %rsi + LONG $0x000005e9; BYTE $0x00 // jmp LBB6_102, $5(%rip) -LBB9_34: - WORD $0x2949; BYTE $0xff // subq %rdi, %r15 - WORD $0xff49; BYTE $0xc7 // incq %r15 - LONG $0xffffe2e9; BYTE $0xff // jmp LBB9_29, $-30(%rip) - -LBB9_63: - LONG $0x02a045f6 // testb $2, $-96(%rbp) - LONG $0x00e5840f; WORD $0x0000 // je LBB9_87, $229(%rip) - LONG $0x06c74166; WORD $0xbfef // movw $-16401, (%r14) - LONG $0x0246c641; BYTE $0xbd // movb $-67, $2(%r14) - LONG $0x03c68349 // addq $3, %r14 - -LBB9_115: - WORD $0x3145; BYTE $0xed // xorl %r13d, %r13d - LONG $0xfffec0e9; BYTE $0xff // jmp LBB9_116, $-320(%rip) - -LBB9_82: - LONG $0xc87d8b4c // movq $-56(%rbp), %r15 +LBB6_101: + LONG $0x21748d4b; BYTE $0x05 // leaq $5(%r9,%r12), %rsi -LBB9_100: - WORD $0x894c; BYTE $0xf8 // movq %r15, %rax - LONG $0xc0452b48 // subq $-64(%rbp), %rax +LBB6_102: + WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax + WORD $0x2948; BYTE $0xf8 // subq %rdi, %rax LONG $0x02c08348 // addq $2, %rax LONG $0xd04d8b48 // movq $-48(%rbp), %rcx WORD $0x8948; BYTE $0x01 // movq %rax, (%rcx) - LONG $0x4fb60f41; BYTE $0x02 // movzbl $2(%r15), %ecx - WORD $0x518d; BYTE $0xc6 // leal $-58(%rcx), %edx - LONG $0xfec6c749; WORD $0xffff; BYTE $0xff // movq $-2, %r14 - WORD $0xfa80; BYTE $0xf5 // cmpb $-11, %dl - LONG $0x000f870f; WORD $0x0000 // ja LBB9_102, $15(%rip) + WORD $0x4e8a; BYTE $0x02 // movb $2(%rsi), %cl + WORD $0x798d; BYTE $0xd0 // leal $-48(%rcx), %edi + LONG $0xfec2c748; WORD $0xffff; BYTE $0xff // movq $-2, %rdx + LONG $0x0aff8040 // cmpb $10, %dil + LONG $0x000f820f; WORD $0x0000 // jb LBB6_104, $15(%rip) WORD $0xe180; BYTE $0xdf // andb $-33, %cl - WORD $0xc180; BYTE $0xb9 // addb $-71, %cl - WORD $0xf980; BYTE $0xfa // cmpb $-6, %cl - LONG $0xfe89820f; WORD $0xffff // jb LBB9_117, $-375(%rip) + WORD $0xc180; BYTE $0xbf // addb $-65, %cl + WORD $0xf980; BYTE $0x05 // cmpb $5, %cl + LONG $0xf82e870f; WORD $0xffff // ja LBB6_4, $-2002(%rip) -LBB9_102: +LBB6_104: LONG $0x01488d48 // leaq $1(%rax), %rcx - LONG $0xd0558b48 // movq $-48(%rbp), %rdx - WORD $0x8948; BYTE $0x0a // movq %rcx, (%rdx) - LONG $0x4fb60f41; BYTE $0x03 // movzbl $3(%r15), %ecx - WORD $0x518d; BYTE $0xc6 // leal $-58(%rcx), %edx - WORD $0xfa80; BYTE $0xf5 // cmpb $-11, %dl - LONG $0x000f870f; WORD $0x0000 // ja LBB9_104, $15(%rip) + LONG $0xd07d8b48 // movq $-48(%rbp), %rdi + WORD $0x8948; BYTE $0x0f // movq %rcx, (%rdi) + WORD $0x4e8a; BYTE $0x03 // movb $3(%rsi), %cl + WORD $0x798d; BYTE $0xd0 // leal $-48(%rcx), %edi + LONG $0x0aff8040 // cmpb $10, %dil + LONG $0x000f820f; WORD $0x0000 // jb LBB6_106, $15(%rip) WORD $0xe180; BYTE $0xdf // andb $-33, %cl - WORD $0xc180; BYTE $0xb9 // addb $-71, %cl - WORD $0xf980; BYTE $0xfa // cmpb $-6, %cl - LONG $0xfe5e820f; WORD $0xffff // jb LBB9_117, $-418(%rip) + WORD $0xc180; BYTE $0xbf // addb $-65, %cl + WORD $0xf980; BYTE $0x05 // cmpb $5, %cl + LONG $0xf804870f; WORD $0xffff // ja LBB6_4, $-2044(%rip) -LBB9_104: +LBB6_106: LONG $0x02488d48 // leaq $2(%rax), %rcx - LONG $0xd0558b48 // movq $-48(%rbp), %rdx - WORD $0x8948; BYTE $0x0a // movq %rcx, (%rdx) - LONG $0x4fb60f41; BYTE $0x04 // movzbl $4(%r15), %ecx - WORD $0x518d; BYTE $0xc6 // leal $-58(%rcx), %edx - WORD $0xfa80; BYTE $0xf5 // cmpb $-11, %dl - LONG $0x000f870f; WORD $0x0000 // ja LBB9_106, $15(%rip) + LONG $0xd07d8b48 // movq $-48(%rbp), %rdi + WORD $0x8948; BYTE $0x0f // movq %rcx, (%rdi) + WORD $0x4e8a; BYTE $0x04 // movb $4(%rsi), %cl + WORD $0x798d; BYTE $0xd0 // leal $-48(%rcx), %edi + LONG $0x0aff8040 // cmpb $10, %dil + LONG $0x000f820f; WORD $0x0000 // jb LBB6_108, $15(%rip) WORD $0xe180; BYTE $0xdf // andb $-33, %cl - WORD $0xc180; BYTE $0xb9 // addb $-71, %cl - WORD $0xf980; BYTE $0xfa // cmpb $-6, %cl - LONG $0xfe33820f; WORD $0xffff // jb LBB9_117, $-461(%rip) + WORD $0xc180; BYTE $0xbf // addb $-65, %cl + WORD $0xf980; BYTE $0x05 // cmpb $5, %cl + LONG $0xf7da870f; WORD $0xffff // ja LBB6_4, $-2086(%rip) -LBB9_106: +LBB6_108: LONG $0x03488d48 // leaq $3(%rax), %rcx - LONG $0xd0558b48 // movq $-48(%rbp), %rdx - WORD $0x8948; BYTE $0x0a // movq %rcx, (%rdx) - LONG $0x4fb60f41; BYTE $0x05 // movzbl $5(%r15), %ecx - WORD $0x518d; BYTE $0xc6 // leal $-58(%rcx), %edx - WORD $0xfa80; BYTE $0xf5 // cmpb $-11, %dl - LONG $0x000f870f; WORD $0x0000 // ja LBB9_108, $15(%rip) + LONG $0xd07d8b48 // movq $-48(%rbp), %rdi + WORD $0x8948; BYTE $0x0f // movq %rcx, (%rdi) + WORD $0x4e8a; BYTE $0x05 // movb $5(%rsi), %cl + WORD $0x718d; BYTE $0xd0 // leal $-48(%rcx), %esi + LONG $0x0afe8040 // cmpb $10, %sil + LONG $0x000f820f; WORD $0x0000 // jb LBB6_110, $15(%rip) WORD $0xe180; BYTE $0xdf // andb $-33, %cl - WORD $0xc180; BYTE $0xb9 // addb $-71, %cl - WORD $0xf980; BYTE $0xfa // cmpb $-6, %cl - LONG $0xfe08820f; WORD $0xffff // jb LBB9_117, $-504(%rip) + WORD $0xc180; BYTE $0xbf // addb $-65, %cl + WORD $0xf980; BYTE $0x05 // cmpb $5, %cl + LONG $0xf7b0870f; WORD $0xffff // ja LBB6_4, $-2128(%rip) -LBB9_108: +LBB6_110: LONG $0x04c08348 // addq $4, %rax LONG $0xd04d8b48 // movq $-48(%rbp), %rcx WORD $0x8948; BYTE $0x01 // movq %rax, (%rcx) - LONG $0xfffdf8e9; BYTE $0xff // jmp LBB9_117, $-520(%rip) + LONG $0xfff7a0e9; BYTE $0xff // jmp LBB6_4, $-2144(%rip) + +LBB6_111: + WORD $0x2949; BYTE $0xf9 // subq %rdi, %r9 + WORD $0xff49; BYTE $0xc1 // incq %r9 -LBB9_87: +LBB6_112: LONG $0xd0458b48 // movq $-48(%rbp), %rax - LONG $0xb84d8b48 // movq $-72(%rbp), %rcx - WORD $0x8948; BYTE $0x08 // movq %rcx, (%rax) - LONG $0xffc6c749; WORD $0xffff; BYTE $0xff // movq $-1, %r14 - LONG $0xfffde1e9; BYTE $0xff // jmp LBB9_117, $-543(%rip) + WORD $0x894c; BYTE $0x08 // movq %r9, (%rax) + LONG $0xfec2c748; WORD $0xffff; BYTE $0xff // movq $-2, %rdx + LONG $0xfff787e9; BYTE $0xff // jmp LBB6_4, $-2169(%rip) + +LBB6_113: + LONG $0x02c0f641 // testb $2, %r8b + LONG $0x0015840f; WORD $0x0000 // je LBB6_116, $21(%rip) + LONG $0xef02c766; BYTE $0xbf // movw $-16401, (%rdx) + LONG $0xbd0242c6 // movb $-67, $2(%rdx) + LONG $0x03c28348 // addq $3, %rdx -LBB9_97: - LONG $0xc87d894c // movq %r15, $-56(%rbp) +LBB6_115: + WORD $0x3145; BYTE $0xed // xorl %r13d, %r13d + LONG $0xfff762e9; BYTE $0xff // jmp LBB6_3, $-2206(%rip) -LBB9_98: - LONG $0xc8658b4c // movq $-56(%rbp), %r12 - LONG $0xc0652b4c // subq $-64(%rbp), %r12 - LONG $0xfcc48349 // addq $-4, %r12 +LBB6_116: LONG $0xd0458b48 // movq $-48(%rbp), %rax - WORD $0x894c; BYTE $0x20 // movq %r12, (%rax) - LONG $0xfcc6c749; WORD $0xffff; BYTE $0xff // movq $-4, %r14 - LONG $0xfffdbee9; BYTE $0xff // jmp LBB9_117, $-578(%rip) - QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90 + WORD $0x8948; BYTE $0x30 // movq %rsi, (%rax) + LONG $0xffc2c748; WORD $0xffff; BYTE $0xff // movq $-1, %rdx + LONG $0xfff755e9; BYTE $0xff // jmp LBB6_4, $-2219(%rip) -_unhex16_is: - BYTE $0x55 // pushq %rbp - WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp - WORD $0xf889 // movl %edi, %eax - WORD $0xd0f7 // notl %eax - LONG $0xcfd08f8d; WORD $0xcfcf // leal $-808464432(%rdi), %ecx - LONG $0x80808025; BYTE $0x80 // andl $-2139062144, %eax - WORD $0xc885 // testl %ecx, %eax - LONG $0x0007840f; WORD $0x0000 // je LBB10_2, $7(%rip) - WORD $0xc031 // xorl %eax, %eax - WORD $0xb60f; BYTE $0xc0 // movzbl %al, %eax - BYTE $0x5d // popq %rbp - BYTE $0xc3 // retq +LBB6_117: + WORD $0x2949; BYTE $0xf9 // subq %rdi, %r9 + LONG $0xfcc18349 // addq $-4, %r9 -LBB10_2: - LONG $0x19198f8d; WORD $0x1919 // leal $421075225(%rdi), %ecx - WORD $0xf909 // orl %edi, %ecx - LONG $0x8080c1f7; WORD $0x8080 // testl $-2139062144, %ecx - LONG $0x0007840f; WORD $0x0000 // je LBB10_4, $7(%rip) - WORD $0xc031 // xorl %eax, %eax - WORD $0xb60f; BYTE $0xc0 // movzbl %al, %eax - BYTE $0x5d // popq %rbp - BYTE $0xc3 // retq +LBB6_118: + LONG $0xd0458b48 // movq $-48(%rbp), %rax + WORD $0x894c; BYTE $0x08 // movq %r9, (%rax) + LONG $0xfcc2c748; WORD $0xffff; BYTE $0xff // movq $-4, %rdx + LONG $0xfff73be9; BYTE $0xff // jmp LBB6_4, $-2245(%rip) -LBB10_4: - LONG $0x7f7fe781; WORD $0x7f7f // andl $2139062143, %edi - LONG $0xc0c0c0b9; BYTE $0xc0 // movl $-1061109568, %ecx - WORD $0xf929 // subl %edi, %ecx - LONG $0x4646978d; WORD $0x4646 // leal $1179010630(%rdi), %edx - WORD $0xc121 // andl %eax, %ecx - WORD $0xd185 // testl %edx, %ecx - LONG $0x0007840f; WORD $0x0000 // je LBB10_6, $7(%rip) - WORD $0xc031 // xorl %eax, %eax - WORD $0xb60f; BYTE $0xc0 // movzbl %al, %eax - BYTE $0x5d // popq %rbp - BYTE $0xc3 // retq +LBB6_119: + LONG $0x21448d4b; BYTE $0x0a // leaq $10(%r9,%r12), %rax + LONG $0x000005e9; BYTE $0x00 // jmp LBB6_121, $5(%rip) -LBB10_6: - LONG $0xe0e0e0b9; BYTE $0xe0 // movl $-522133280, %ecx - WORD $0xf929 // subl %edi, %ecx - LONG $0x3939c781; WORD $0x3939 // addl $960051513, %edi - WORD $0xc821 // andl %ecx, %eax - WORD $0xf885 // testl %edi, %eax - WORD $0x940f; BYTE $0xc0 // sete %al - WORD $0xb60f; BYTE $0xc0 // movzbl %al, %eax - BYTE $0x5d // popq %rbp - BYTE $0xc3 // retq - LONG $0x00000000; WORD $0x0000 // .p2align 5, 0x00 +LBB6_120: + LONG $0x21448d4b; BYTE $0x0b // leaq $11(%r9,%r12), %rax -LCPI11_0: +LBB6_121: + WORD $0x2948; BYTE $0xf8 // subq %rdi, %rax + LONG $0xfcc08348 // addq $-4, %rax + LONG $0xd04d8b48 // movq $-48(%rbp), %rcx + WORD $0x8948; BYTE $0x01 // movq %rax, (%rcx) + LONG $0xfcc2c748; WORD $0xffff; BYTE $0xff // movq $-4, %rdx + LONG $0xfff712e9; BYTE $0xff // jmp LBB6_4, $-2286(%rip) + +LBB6_122: + LONG $0x3a448d49; BYTE $0x04 // leaq $4(%r10,%rdi), %rax + WORD $0x2949; BYTE $0xc1 // subq %rax, %r9 + LONG $0xffffb7e9; BYTE $0xff // jmp LBB6_118, $-73(%rip) + +LBB6_123: + WORD $0x014d; BYTE $0xe1 // addq %r12, %r9 + WORD $0x2949; BYTE $0xf9 // subq %rdi, %r9 + LONG $0xfffface9; BYTE $0xff // jmp LBB6_118, $-84(%rip) + QUAD $0x0000000000000000; QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .p2align 5, 0x00 + +LCPI7_0: QUAD $0x2626262626262626; QUAD $0x2626262626262626 // .space 16, '&&&&&&&&&&&&&&&&' QUAD $0x2626262626262626; QUAD $0x2626262626262626 // .space 16, '&&&&&&&&&&&&&&&&' -LCPI11_1: +LCPI7_1: QUAD $0xe2e2e2e2e2e2e2e2; QUAD $0xe2e2e2e2e2e2e2e2 // .space 16, '\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2' QUAD $0xe2e2e2e2e2e2e2e2; QUAD $0xe2e2e2e2e2e2e2e2 // .space 16, '\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2' -LCPI11_2: +LCPI7_2: QUAD $0xfdfdfdfdfdfdfdfd; QUAD $0xfdfdfdfdfdfdfdfd // .space 16, '\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd' QUAD $0xfdfdfdfdfdfdfdfd; QUAD $0xfdfdfdfdfdfdfdfd // .space 16, '\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd' -LCPI11_3: +LCPI7_3: QUAD $0x3c3c3c3c3c3c3c3c; QUAD $0x3c3c3c3c3c3c3c3c // .space 16, '<<<<<<<<<<<<<<<<' QUAD $0x3c3c3c3c3c3c3c3c; QUAD $0x3c3c3c3c3c3c3c3c // .space 16, '<<<<<<<<<<<<<<<<' // .p2align 4, 0x00 -LCPI11_4: +LCPI7_4: QUAD $0x2626262626262626; QUAD $0x2626262626262626 // .space 16, '&&&&&&&&&&&&&&&&' -LCPI11_5: +LCPI7_5: QUAD $0xe2e2e2e2e2e2e2e2; QUAD $0xe2e2e2e2e2e2e2e2 // .space 16, '\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2' -LCPI11_6: +LCPI7_6: QUAD $0xfdfdfdfdfdfdfdfd; QUAD $0xfdfdfdfdfdfdfdfd // .space 16, '\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd' -LCPI11_7: +LCPI7_7: QUAD $0x3c3c3c3c3c3c3c3c; QUAD $0x3c3c3c3c3c3c3c3c // .space 16, '<<<<<<<<<<<<<<<<' // .p2align 4, 0x90 _html_escape: - BYTE $0x55 // pushq %rbp - WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp - WORD $0x5741 // pushq %r15 - WORD $0x5641 // pushq %r14 - WORD $0x5541 // pushq %r13 - WORD $0x5441 // pushq %r12 - BYTE $0x53 // pushq %rbx - LONG $0x18ec8348 // subq $24, %rsp - LONG $0xc04d8948 // movq %rcx, $-64(%rbp) - WORD $0x8949; BYTE $0xd7 // movq %rdx, %r15 - LONG $0xc8558948 // movq %rdx, $-56(%rbp) - LONG $0xd07d8948 // movq %rdi, $-48(%rbp) - WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax - WORD $0x8548; BYTE $0xf6 // testq %rsi, %rsi - LONG $0x07e98e0f; WORD $0x0000 // jle LBB11_105, $2025(%rip) - LONG $0xc0458b48 // movq $-64(%rbp), %rax - WORD $0x8b4c; BYTE $0x08 // movq (%rax), %r9 - QUAD $0xffffff051d6ffdc5 // vmovdqa $-251(%rip), %ymm3 /* LCPI11_0(%rip) */ - QUAD $0xffffff1d256ffdc5 // vmovdqa $-227(%rip), %ymm4 /* LCPI11_1(%rip) */ - QUAD $0xffffff352d6ffdc5 // vmovdqa $-203(%rip), %ymm5 /* LCPI11_2(%rip) */ - QUAD $0xffffff4d356ffdc5 // vmovdqa $-179(%rip), %ymm6 /* LCPI11_3(%rip) */ - LONG $0x362d8d4c; WORD $0x00eb; BYTE $0x00 // leaq $60214(%rip), %r13 /* __HtmlQuoteTab(%rip) */ - LONG $0xd05d8b4c // movq $-48(%rbp), %r11 - LONG $0xc87d8b4c // movq $-56(%rbp), %r15 - QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5741 // pushq %r15 + WORD $0x5641 // pushq %r14 + WORD $0x5541 // pushq %r13 + WORD $0x5441 // pushq %r12 + BYTE $0x53 // pushq %rbx + LONG $0x18ec8348 // subq $24, %rsp + LONG $0xc04d8948 // movq %rcx, $-64(%rbp) + LONG $0xc8558948 // movq %rdx, $-56(%rbp) + WORD $0x8949; BYTE $0xd0 // movq %rdx, %r8 + LONG $0xd07d8948 // movq %rdi, $-48(%rbp) + WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax + WORD $0x8548; BYTE $0xf6 // testq %rsi, %rsi + LONG $0x075f8e0f; WORD $0x0000 // jle LBB7_102, $1887(%rip) + WORD $0x8949; BYTE $0xf3 // movq %rsi, %r11 + LONG $0xc0458b48 // movq $-64(%rbp), %rax + WORD $0x8b4c; BYTE $0x08 // movq (%rax), %r9 + QUAD $0xffffff021d6ffdc5 // vmovdqa $-254(%rip), %ymm3 /* LCPI7_0(%rip) */ + QUAD $0xffffff1a256ffdc5 // vmovdqa $-230(%rip), %ymm4 /* LCPI7_1(%rip) */ + QUAD $0xffffff322d6ffdc5 // vmovdqa $-206(%rip), %ymm5 /* LCPI7_2(%rip) */ + QUAD $0xffffff4a356ffdc5 // vmovdqa $-182(%rip), %ymm6 /* LCPI7_3(%rip) */ + LONG $0x733d8d4c; WORD $0x00e6; BYTE $0x00 // leaq $58995(%rip), %r15 /* __HtmlQuoteTab(%rip) */ + QUAD $0x000300000001bf48; WORD $0x0000 // movabsq $12884901889, %rdi + LONG $0xd0658b4c // movq $-48(%rbp), %r12 + LONG $0xc8458b4c // movq $-56(%rbp), %r8 + BYTE $0x90 // .p2align 4, 0x90 -LBB11_2: - WORD $0x854d; BYTE $0xc9 // testq %r9, %r9 - LONG $0x07bb8e0f; WORD $0x0000 // jle LBB11_3, $1979(%rip) - LONG $0x20fe8348 // cmpq $32, %rsi - WORD $0x930f; BYTE $0xc1 // setae %cl - WORD $0x894c; BYTE $0xc8 // movq %r9, %rax - WORD $0x894d; BYTE $0xf8 // movq %r15, %r8 - WORD $0x8949; BYTE $0xf2 // movq %rsi, %r10 - WORD $0x894d; BYTE $0xdc // movq %r11, %r12 - LONG $0x20f98349 // cmpq $32, %r9 - LONG $0x007a820f; WORD $0x0000 // jb LBB11_12, $122(%rip) - LONG $0x20fe8348 // cmpq $32, %rsi - LONG $0x0070820f; WORD $0x0000 // jb LBB11_12, $112(%rip) - WORD $0x3145; BYTE $0xc0 // xorl %r8d, %r8d - WORD $0x8948; BYTE $0xf3 // movq %rsi, %rbx - WORD $0x894c; BYTE $0xcf // movq %r9, %rdi - LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 +LBB7_2: + WORD $0x854d; BYTE $0xc9 // testq %r9, %r9 + LONG $0x07318e0f; WORD $0x0000 // jle LBB7_3, $1841(%rip) + LONG $0x1ffb8349 // cmpq $31, %r11 + WORD $0x9f0f; BYTE $0xc1 // setg %cl + WORD $0x894d; BYTE $0xca // movq %r9, %r10 + WORD $0x894c; BYTE $0xc3 // movq %r8, %rbx + WORD $0x894d; BYTE $0xde // movq %r11, %r14 + WORD $0x894d; BYTE $0xe5 // movq %r12, %r13 + LONG $0x20f98349 // cmpq $32, %r9 + LONG $0x007a8c0f; WORD $0x0000 // jl LBB7_11, $122(%rip) + LONG $0x20fb8349 // cmpq $32, %r11 + LONG $0x00708c0f; WORD $0x0000 // jl LBB7_11, $112(%rip) + WORD $0x894d; BYTE $0xe5 // movq %r12, %r13 + WORD $0x894c; BYTE $0xde // movq %r11, %rsi + WORD $0x894c; BYTE $0xc3 // movq %r8, %rbx + WORD $0x894c; BYTE $0xc8 // movq %r9, %rax + LONG $0x90909090 // .p2align 4, 0x90 -LBB11_7: - LONG $0x6f7e81c4; WORD $0x0304 // vmovdqu (%r11,%r8), %ymm0 +LBB7_7: + LONG $0x6f7ec1c4; WORD $0x0045 // vmovdqu (%r13), %ymm0 LONG $0xcb74fdc5 // vpcmpeqb %ymm3, %ymm0, %ymm1 LONG $0xd474fdc5 // vpcmpeqb %ymm4, %ymm0, %ymm2 LONG $0xc9ebedc5 // vpor %ymm1, %ymm2, %ymm1 LONG $0xd5dbfdc5 // vpand %ymm5, %ymm0, %ymm2 LONG $0xd674edc5 // vpcmpeqb %ymm6, %ymm2, %ymm2 LONG $0xcaebf5c5 // vpor %ymm2, %ymm1, %ymm1 - LONG $0x7f7e81c4; WORD $0x0704 // vmovdqu %ymm0, (%r15,%r8) - LONG $0xc1d7fdc5 // vpmovmskb %ymm1, %eax - WORD $0xc085 // testl %eax, %eax - LONG $0x0180850f; WORD $0x0000 // jne LBB11_8, $384(%rip) - LONG $0xe0538d4c // leaq $-32(%rbx), %r10 - LONG $0xe0478d48 // leaq $-32(%rdi), %rax - LONG $0x20c08349 // addq $32, %r8 - LONG $0x40fb8348 // cmpq $64, %rbx - WORD $0x9d0f; BYTE $0xc1 // setge %cl - LONG $0x00108c0f; WORD $0x0000 // jl LBB11_11, $16(%rip) - WORD $0x894c; BYTE $0xd3 // movq %r10, %rbx - LONG $0x3fff8348 // cmpq $63, %rdi - WORD $0x8948; BYTE $0xc7 // movq %rax, %rdi - LONG $0xffa78f0f; WORD $0xffff // jg LBB11_7, $-89(%rip) - -LBB11_11: - LONG $0x03248d4f // leaq (%r11,%r8), %r12 - WORD $0x014d; BYTE $0xf8 // addq %r15, %r8 - -LBB11_12: - WORD $0xc984 // testb %cl, %cl - LONG $0x0078840f; WORD $0x0000 // je LBB11_38, $120(%rip) - LONG $0x6f7ec1c4; WORD $0x2404 // vmovdqu (%r12), %ymm0 - LONG $0xcb74fdc5 // vpcmpeqb %ymm3, %ymm0, %ymm1 - LONG $0xd474fdc5 // vpcmpeqb %ymm4, %ymm0, %ymm2 - LONG $0xc9ebedc5 // vpor %ymm1, %ymm2, %ymm1 - LONG $0xc5dbfdc5 // vpand %ymm5, %ymm0, %ymm0 - LONG $0xc674fdc5 // vpcmpeqb %ymm6, %ymm0, %ymm0 - LONG $0xc0ebf5c5 // vpor %ymm0, %ymm1, %ymm0 - LONG $0xc8d7fdc5 // vpmovmskb %ymm0, %ecx - QUAD $0x000100000000ba48; WORD $0x0000 // movabsq $4294967296, %rdx - WORD $0x0948; BYTE $0xd1 // orq %rdx, %rcx - LONG $0xd1bc0f4c // bsfq %rcx, %r10 - LONG $0x243c8b49 // movq (%r12), %rdi - LONG $0x244c8b49; BYTE $0x08 // movq $8(%r12), %rcx - WORD $0x3949; BYTE $0xc2 // cmpq %rax, %r10 - LONG $0x01188e0f; WORD $0x0000 // jle LBB11_14, $280(%rip) - LONG $0x10f88348 // cmpq $16, %rax - LONG $0x015b820f; WORD $0x0000 // jb LBB11_27, $347(%rip) - WORD $0x8949; BYTE $0x38 // movq %rdi, (%r8) - LONG $0x08488949 // movq %rcx, $8(%r8) - LONG $0x24548d4d; BYTE $0x10 // leaq $16(%r12), %r10 - LONG $0x10c08349 // addq $16, %r8 - LONG $0xf0708d4c // leaq $-16(%rax), %r14 - LONG $0x08fe8349 // cmpq $8, %r14 - LONG $0x014d830f; WORD $0x0000 // jae LBB11_30, $333(%rip) - LONG $0x00015ae9; BYTE $0x00 // jmp LBB11_31, $346(%rip) - LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 - -LBB11_38: - WORD $0xf8c5; BYTE $0x77 // vzeroupper - LONG $0x10fa8349 // cmpq $16, %r10 - WORD $0x9d0f; BYTE $0xc1 // setge %cl - LONG $0x01828c0f; WORD $0x0000 // jl LBB11_39, $386(%rip) - LONG $0x10f88348 // cmpq $16, %rax - QUAD $0xfffffe143d6ff9c5 // vmovdqa $-492(%rip), %xmm7 /* LCPI11_4(%rip) */ - QUAD $0xfffffe1c056f79c5 // vmovdqa $-484(%rip), %xmm8 /* LCPI11_5(%rip) */ - QUAD $0xfffffe240d6f79c5 // vmovdqa $-476(%rip), %xmm9 /* LCPI11_6(%rip) */ - QUAD $0xfffffe2c156f79c5 // vmovdqa $-468(%rip), %xmm10 /* LCPI11_7(%rip) */ - LONG $0x02078c0f; WORD $0x0000 // jl LBB11_41, $519(%rip) - WORD $0x894c; BYTE $0xdf // movq %r11, %rdi - WORD $0x294c; BYTE $0xe7 // subq %r12, %rdi - QUAD $0xfffffd681d6ffdc5 // vmovdqa $-664(%rip), %ymm3 /* LCPI11_0(%rip) */ - QUAD $0xfffffd80256ffdc5 // vmovdqa $-640(%rip), %ymm4 /* LCPI11_1(%rip) */ - QUAD $0xfffffd982d6ffdc5 // vmovdqa $-616(%rip), %ymm5 /* LCPI11_2(%rip) */ - QUAD $0xfffffdb0356ffdc5 // vmovdqa $-592(%rip), %ymm6 /* LCPI11_3(%rip) */ + LONG $0x037ffec5 // vmovdqu %ymm0, (%rbx) + LONG $0xc9d7fdc5 // vpmovmskb %ymm1, %ecx + WORD $0xc985 // testl %ecx, %ecx + LONG $0x01a2850f; WORD $0x0000 // jne LBB7_8, $418(%rip) + LONG $0x20c58349 // addq $32, %r13 + LONG $0x20c38348 // addq $32, %rbx + LONG $0xe0768d4c // leaq $-32(%rsi), %r14 + LONG $0xe0508d4c // leaq $-32(%rax), %r10 + LONG $0x3ffe8348 // cmpq $63, %rsi + WORD $0x9f0f; BYTE $0xc1 // setg %cl + LONG $0x40fe8348 // cmpq $64, %rsi + LONG $0x00118c0f; WORD $0x0000 // jl LBB7_11, $17(%rip) + WORD $0x894c; BYTE $0xf6 // movq %r14, %rsi + LONG $0x3ff88348 // cmpq $63, %rax + WORD $0x894c; BYTE $0xd0 // movq %r10, %rax + LONG $0xffa18f0f; WORD $0xffff // jg LBB7_7, $-95(%rip) + BYTE $0x90 // .p2align 4, 0x90 - // .p2align 4, 0x90 -LBB11_43: - LONG $0x6f7ac1c4; WORD $0x2404 // vmovdqu (%r12), %xmm0 - LONG $0xcf74f9c5 // vpcmpeqb %xmm7, %xmm0, %xmm1 - LONG $0xd074b9c5 // vpcmpeqb %xmm0, %xmm8, %xmm2 - LONG $0xc9ebe9c5 // vpor %xmm1, %xmm2, %xmm1 - LONG $0xd0dbb1c5 // vpand %xmm0, %xmm9, %xmm2 - LONG $0xd274a9c5 // vpcmpeqb %xmm2, %xmm10, %xmm2 - LONG $0xcaebf1c5 // vpor %xmm2, %xmm1, %xmm1 - LONG $0x7f7ac1c4; BYTE $0x00 // vmovdqu %xmm0, (%r8) - LONG $0xc9d7f9c5 // vpmovmskb %xmm1, %ecx - WORD $0xc985 // testl %ecx, %ecx - LONG $0x0083850f; WORD $0x0000 // jne LBB11_44, $131(%rip) - LONG $0x10c48349 // addq $16, %r12 - LONG $0x10c08349 // addq $16, %r8 - LONG $0xf0728d4d // leaq $-16(%r10), %r14 - LONG $0xf0688d4c // leaq $-16(%rax), %r13 - LONG $0x20fa8349 // cmpq $32, %r10 - WORD $0x9d0f; BYTE $0xc1 // setge %cl - LONG $0x012c8c0f; WORD $0x0000 // jl LBB11_47, $300(%rip) - LONG $0xf0c78348 // addq $-16, %rdi - WORD $0x894d; BYTE $0xf2 // movq %r14, %r10 - LONG $0x1ff88348 // cmpq $31, %rax - WORD $0x894c; BYTE $0xe8 // movq %r13, %rax - LONG $0xffa08f0f; WORD $0xffff // jg LBB11_43, $-96(%rip) - LONG $0x000113e9; BYTE $0x00 // jmp LBB11_47, $275(%rip) - QUAD $0x9090909090909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 +LBB7_11: + WORD $0xc984 // testb %cl, %cl + LONG $0x0088840f; WORD $0x0000 // je LBB7_37, $136(%rip) + LONG $0x6f7ec1c4; WORD $0x0045 // vmovdqu (%r13), %ymm0 + LONG $0xcb74fdc5 // vpcmpeqb %ymm3, %ymm0, %ymm1 + LONG $0xd474fdc5 // vpcmpeqb %ymm4, %ymm0, %ymm2 + LONG $0xc9ebedc5 // vpor %ymm1, %ymm2, %ymm1 + LONG $0xc5dbfdc5 // vpand %ymm5, %ymm0, %ymm0 + LONG $0xc674fdc5 // vpcmpeqb %ymm6, %ymm0, %ymm0 + LONG $0xc0ebf5c5 // vpor %ymm0, %ymm1, %ymm0 + LONG $0xc0d7fdc5 // vpmovmskb %ymm0, %eax + QUAD $0x000100000000b948; WORD $0x0000 // movabsq $4294967296, %rcx + WORD $0x0948; BYTE $0xc8 // orq %rcx, %rax + LONG $0xc8bc0f48 // bsfq %rax, %rcx + LONG $0x6f7ac1c4; WORD $0x0045 // vmovdqu (%r13), %xmm0 + LONG $0x16f9e3c4; WORD $0x01c0 // vpextrq $1, %xmm0, %rax + LONG $0x7ef9e1c4; BYTE $0xc2 // vmovq %xmm0, %rdx + WORD $0x394c; BYTE $0xd1 // cmpq %r10, %rcx + LONG $0x012a8e0f; WORD $0x0000 // jle LBB7_13, $298(%rip) + LONG $0x10fa8349 // cmpq $16, %r10 + LONG $0x0160820f; WORD $0x0000 // jb LBB7_26, $352(%rip) + WORD $0x8948; BYTE $0x13 // movq %rdx, (%rbx) + LONG $0x08438948 // movq %rax, $8(%rbx) + LONG $0x10458d49 // leaq $16(%r13), %rax + LONG $0x10c38348 // addq $16, %rbx + LONG $0xf0728d49 // leaq $-16(%r10), %rsi + LONG $0x08fe8348 // cmpq $8, %rsi + LONG $0x0153830f; WORD $0x0000 // jae LBB7_29, $339(%rip) + LONG $0x000160e9; BYTE $0x00 // jmp LBB7_30, $352(%rip) + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 -LBB11_8: - LONG $0xe0bc0f44 // bsfl %eax, %r12d - WORD $0x014d; BYTE $0xc4 // addq %r8, %r12 - WORD $0x854d; BYTE $0xe4 // testq %r12, %r12 - LONG $0x0460890f; WORD $0x0000 // jns LBB11_84, $1120(%rip) - LONG $0x00057ae9; BYTE $0x00 // jmp LBB11_83, $1402(%rip) +LBB7_37: + WORD $0x894c; BYTE $0xfa // movq %r15, %rdx + WORD $0xf8c5; BYTE $0x77 // vzeroupper + LONG $0x0ffe8349 // cmpq $15, %r14 + LONG $0xc79f0f41 // setg %r15b + LONG $0x10fa8349 // cmpq $16, %r10 + LONG $0x01688c0f; WORD $0x0000 // jl LBB7_38, $360(%rip) + LONG $0x10fe8349 // cmpq $16, %r14 + QUAD $0xfffffdfc3d6ff9c5 // vmovdqa $-516(%rip), %xmm7 /* LCPI7_4(%rip) */ + QUAD $0xfffffe04056f79c5 // vmovdqa $-508(%rip), %xmm8 /* LCPI7_5(%rip) */ + QUAD $0xfffffe0c0d6f79c5 // vmovdqa $-500(%rip), %xmm9 /* LCPI7_6(%rip) */ + QUAD $0xfffffe14156f79c5 // vmovdqa $-492(%rip), %xmm10 /* LCPI7_7(%rip) */ + LONG $0x01f08c0f; WORD $0x0000 // jl LBB7_40, $496(%rip) + QUAD $0xfffffd561d6ffdc5 // vmovdqa $-682(%rip), %ymm3 /* LCPI7_0(%rip) */ + QUAD $0xfffffd6e256ffdc5 // vmovdqa $-658(%rip), %ymm4 /* LCPI7_1(%rip) */ + QUAD $0xfffffd862d6ffdc5 // vmovdqa $-634(%rip), %ymm5 /* LCPI7_2(%rip) */ + QUAD $0xfffffd9e356ffdc5 // vmovdqa $-610(%rip), %ymm6 /* LCPI7_3(%rip) */ + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 -LBB11_14: - LONG $0x10fa8341 // cmpl $16, %r10d - LONG $0x0223820f; WORD $0x0000 // jb LBB11_15, $547(%rip) - WORD $0x8949; BYTE $0x38 // movq %rdi, (%r8) - LONG $0x08488949 // movq %rcx, $8(%r8) - LONG $0x24748d4d; BYTE $0x10 // leaq $16(%r12), %r14 - LONG $0x10c08349 // addq $16, %r8 - LONG $0xf0428d49 // leaq $-16(%r10), %rax - LONG $0x08f88348 // cmpq $8, %rax - LONG $0x0215830f; WORD $0x0000 // jae LBB11_18, $533(%rip) - LONG $0x000222e9; BYTE $0x00 // jmp LBB11_19, $546(%rip) +LBB7_42: + LONG $0x6f7ac1c4; WORD $0x0045 // vmovdqu (%r13), %xmm0 + LONG $0xcf74f9c5 // vpcmpeqb %xmm7, %xmm0, %xmm1 + LONG $0xd074b9c5 // vpcmpeqb %xmm0, %xmm8, %xmm2 + LONG $0xc9ebe9c5 // vpor %xmm1, %xmm2, %xmm1 + LONG $0xd0dbb1c5 // vpand %xmm0, %xmm9, %xmm2 + LONG $0xd274a9c5 // vpcmpeqb %xmm2, %xmm10, %xmm2 + LONG $0xcaebf1c5 // vpor %xmm2, %xmm1, %xmm1 + LONG $0x037ffac5 // vmovdqu %xmm0, (%rbx) + LONG $0xc1d7f9c5 // vpmovmskb %xmm1, %eax + WORD $0x8566; BYTE $0xc0 // testw %ax, %ax + LONG $0x007b850f; WORD $0x0000 // jne LBB7_43, $123(%rip) + LONG $0x10c58349 // addq $16, %r13 + LONG $0x10c38348 // addq $16, %rbx + LONG $0xf0468d49 // leaq $-16(%r14), %rax + LONG $0xf04a8d49 // leaq $-16(%r10), %rcx + LONG $0x1ffe8349 // cmpq $31, %r14 + LONG $0xc79f0f41 // setg %r15b + LONG $0x20fe8349 // cmpq $32, %r14 + LONG $0x01058c0f; WORD $0x0000 // jl LBB7_46, $261(%rip) + WORD $0x8949; BYTE $0xc6 // movq %rax, %r14 + LONG $0x1ffa8349 // cmpq $31, %r10 + WORD $0x8949; BYTE $0xca // movq %rcx, %r10 + LONG $0xff9f8f0f; WORD $0xffff // jg LBB7_42, $-97(%rip) + LONG $0x0000f0e9; BYTE $0x00 // jmp LBB7_46, $240(%rip) + QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90 -LBB11_44: - LONG $0xc1bc0f66 // bsfw %cx, %ax - LONG $0xe0b70f44 // movzwl %ax, %r12d - WORD $0x2949; BYTE $0xfc // subq %rdi, %r12 - LONG $0xdc2d8d4c; WORD $0x00e8; BYTE $0x00 // leaq $59612(%rip), %r13 /* __HtmlQuoteTab(%rip) */ - WORD $0x854d; BYTE $0xe4 // testq %r12, %r12 - LONG $0x0413890f; WORD $0x0000 // jns LBB11_84, $1043(%rip) - LONG $0x00052de9; BYTE $0x00 // jmp LBB11_83, $1325(%rip) +LBB7_8: + WORD $0x294d; BYTE $0xe5 // subq %r12, %r13 + LONG $0xd1bc0f44 // bsfl %ecx, %r10d + WORD $0x014d; BYTE $0xea // addq %r13, %r10 + LONG $0x00037be9; BYTE $0x00 // jmp LBB7_79, $891(%rip) -LBB11_27: - WORD $0x894d; BYTE $0xe2 // movq %r12, %r10 - WORD $0x8949; BYTE $0xc6 // movq %rax, %r14 - LONG $0x08fe8349 // cmpq $8, %r14 - LONG $0x0012820f; WORD $0x0000 // jb LBB11_31, $18(%rip) +LBB7_13: + WORD $0xf983; BYTE $0x10 // cmpl $16, %ecx + LONG $0x01e3820f; WORD $0x0000 // jb LBB7_14, $483(%rip) + WORD $0x8948; BYTE $0x13 // movq %rdx, (%rbx) + LONG $0x08438948 // movq %rax, $8(%rbx) + LONG $0x10458d49 // leaq $16(%r13), %rax + LONG $0x10c38348 // addq $16, %rbx + LONG $0xf0718d48 // leaq $-16(%rcx), %rsi + LONG $0x08fe8348 // cmpq $8, %rsi + LONG $0x01d6830f; WORD $0x0000 // jae LBB7_17, $470(%rip) + LONG $0x0001e3e9; BYTE $0x00 // jmp LBB7_18, $483(%rip) -LBB11_30: - WORD $0x8b49; BYTE $0x0a // movq (%r10), %rcx - WORD $0x8949; BYTE $0x08 // movq %rcx, (%r8) - LONG $0x08c28349 // addq $8, %r10 - LONG $0x08c08349 // addq $8, %r8 - LONG $0xf8c68349 // addq $-8, %r14 +LBB7_43: + WORD $0xb70f; BYTE $0xc0 // movzwl %ax, %eax + WORD $0x294d; BYTE $0xe5 // subq %r12, %r13 + LONG $0xd0bc0f44 // bsfl %eax, %r10d + WORD $0x014d; BYTE $0xea // addq %r13, %r10 + WORD $0x8949; BYTE $0xd7 // movq %rdx, %r15 + LONG $0x00033be9; BYTE $0x00 // jmp LBB7_79, $827(%rip) -LBB11_31: - LONG $0x04fe8349 // cmpq $4, %r14 - LONG $0x020e8d0f; WORD $0x0000 // jge LBB11_32, $526(%rip) - LONG $0x02fe8349 // cmpq $2, %r14 - LONG $0x0220830f; WORD $0x0000 // jae LBB11_34, $544(%rip) +LBB7_26: + WORD $0x894c; BYTE $0xe8 // movq %r13, %rax + WORD $0x894c; BYTE $0xd6 // movq %r10, %rsi + LONG $0x08fe8348 // cmpq $8, %rsi + LONG $0x0012820f; WORD $0x0000 // jb LBB7_30, $18(%rip) -LBB11_35: - WORD $0x854d; BYTE $0xf6 // testq %r14, %r14 - LONG $0x0007840f; WORD $0x0000 // je LBB11_37, $7(%rip) +LBB7_29: + WORD $0x8b48; BYTE $0x08 // movq (%rax), %rcx + WORD $0x8948; BYTE $0x0b // movq %rcx, (%rbx) + LONG $0x08c08348 // addq $8, %rax + LONG $0x08c38348 // addq $8, %rbx + LONG $0xf8c68348 // addq $-8, %rsi -LBB11_36: - LONG $0x0ab60f41 // movzbl (%r10), %ecx - WORD $0x8841; BYTE $0x08 // movb %cl, (%r8) +LBB7_30: + LONG $0x04fe8348 // cmpq $4, %rsi + LONG $0x01ce8d0f; WORD $0x0000 // jge LBB7_31, $462(%rip) + LONG $0x02fe8348 // cmpq $2, %rsi + LONG $0x01de830f; WORD $0x0000 // jae LBB7_33, $478(%rip) -LBB11_37: - WORD $0x014c; BYTE $0xe0 // addq %r12, %rax - WORD $0xf748; BYTE $0xd0 // notq %rax - WORD $0x014c; BYTE $0xd8 // addq %r11, %rax - WORD $0x8949; BYTE $0xc4 // movq %rax, %r12 - WORD $0x854d; BYTE $0xe4 // testq %r12, %r12 - LONG $0x03b3890f; WORD $0x0000 // jns LBB11_84, $947(%rip) - LONG $0x0004cde9; BYTE $0x00 // jmp LBB11_83, $1229(%rip) +LBB7_34: + WORD $0x8548; BYTE $0xf6 // testq %rsi, %rsi + LONG $0x0004840f; WORD $0x0000 // je LBB7_36, $4(%rip) -LBB11_39: - WORD $0x8949; BYTE $0xc5 // movq %rax, %r13 - WORD $0x894d; BYTE $0xd6 // movq %r10, %r14 - QUAD $0xfffffc101d6ffdc5 // vmovdqa $-1008(%rip), %ymm3 /* LCPI11_0(%rip) */ - QUAD $0xfffffc28256ffdc5 // vmovdqa $-984(%rip), %ymm4 /* LCPI11_1(%rip) */ - QUAD $0xfffffc402d6ffdc5 // vmovdqa $-960(%rip), %ymm5 /* LCPI11_2(%rip) */ - QUAD $0xfffffc58356ffdc5 // vmovdqa $-936(%rip), %ymm6 /* LCPI11_3(%rip) */ - QUAD $0xfffffc703d6ff9c5 // vmovdqa $-912(%rip), %xmm7 /* LCPI11_4(%rip) */ - QUAD $0xfffffc78056f79c5 // vmovdqa $-904(%rip), %xmm8 /* LCPI11_5(%rip) */ - QUAD $0xfffffc800d6f79c5 // vmovdqa $-896(%rip), %xmm9 /* LCPI11_6(%rip) */ - QUAD $0xfffffc88156f79c5 // vmovdqa $-888(%rip), %xmm10 /* LCPI11_7(%rip) */ +LBB7_35: + WORD $0x008a // movb (%rax), %al + WORD $0x0388 // movb %al, (%rbx) -LBB11_47: - WORD $0xc984 // testb %cl, %cl - LONG $0x008f840f; WORD $0x0000 // je LBB11_48, $143(%rip) +LBB7_36: + WORD $0x294d; BYTE $0xe2 // subq %r12, %r10 + WORD $0x014d; BYTE $0xea // addq %r13, %r10 + WORD $0xf749; BYTE $0xd2 // notq %r10 + LONG $0x0002eae9; BYTE $0x00 // jmp LBB7_79, $746(%rip) -LBB11_58: - LONG $0x6f7ac1c4; WORD $0x2404 // vmovdqu (%r12), %xmm0 +LBB7_38: + WORD $0x894c; BYTE $0xd1 // movq %r10, %rcx + WORD $0x894c; BYTE $0xf0 // movq %r14, %rax + QUAD $0xfffffc121d6ffdc5 // vmovdqa $-1006(%rip), %ymm3 /* LCPI7_0(%rip) */ + QUAD $0xfffffc2a256ffdc5 // vmovdqa $-982(%rip), %ymm4 /* LCPI7_1(%rip) */ + QUAD $0xfffffc422d6ffdc5 // vmovdqa $-958(%rip), %ymm5 /* LCPI7_2(%rip) */ + QUAD $0xfffffc5a356ffdc5 // vmovdqa $-934(%rip), %ymm6 /* LCPI7_3(%rip) */ + QUAD $0xfffffc723d6ff9c5 // vmovdqa $-910(%rip), %xmm7 /* LCPI7_4(%rip) */ + QUAD $0xfffffc7a056f79c5 // vmovdqa $-902(%rip), %xmm8 /* LCPI7_5(%rip) */ + QUAD $0xfffffc820d6f79c5 // vmovdqa $-894(%rip), %xmm9 /* LCPI7_6(%rip) */ + QUAD $0xfffffc8a156f79c5 // vmovdqa $-886(%rip), %xmm10 /* LCPI7_7(%rip) */ + +LBB7_46: + WORD $0x8445; BYTE $0xff // testb %r15b, %r15b + LONG $0x0092840f; WORD $0x0000 // je LBB7_47, $146(%rip) + +LBB7_49: + LONG $0x6f7ac1c4; WORD $0x0045 // vmovdqu (%r13), %xmm0 LONG $0xcf74f9c5 // vpcmpeqb %xmm7, %xmm0, %xmm1 LONG $0xd074b9c5 // vpcmpeqb %xmm0, %xmm8, %xmm2 LONG $0xc9ebe9c5 // vpor %xmm1, %xmm2, %xmm1 @@ -3479,525 +3185,505 @@ LBB11_58: LONG $0xcaebf1c5 // vpor %xmm2, %xmm1, %xmm1 LONG $0xc1d7f9c5 // vpmovmskb %xmm1, %eax LONG $0x0100000d; BYTE $0x00 // orl $65536, %eax - WORD $0xbc0f; BYTE $0xc0 // bsfl %eax, %eax - LONG $0x7ef9e1c4; BYTE $0xc1 // vmovq %xmm0, %rcx - WORD $0x3949; BYTE $0xc5 // cmpq %rax, %r13 - LONG $0x01d08d0f; WORD $0x0000 // jge LBB11_59, $464(%rip) - LONG $0x08fd8349 // cmpq $8, %r13 - LONG $0x0210820f; WORD $0x0000 // jb LBB11_70, $528(%rip) - WORD $0x8949; BYTE $0x08 // movq %rcx, (%r8) - LONG $0x24448d49; BYTE $0x08 // leaq $8(%r12), %rax - LONG $0x08c08349 // addq $8, %r8 - LONG $0xf87d8d49 // leaq $-8(%r13), %rdi - LONG $0x04ff8348 // cmpq $4, %rdi - LONG $0x02068d0f; WORD $0x0000 // jge LBB11_73, $518(%rip) - LONG $0x000212e9; BYTE $0x00 // jmp LBB11_74, $530(%rip) - -LBB11_41: - WORD $0x8949; BYTE $0xc5 // movq %rax, %r13 - WORD $0x894d; BYTE $0xd6 // movq %r10, %r14 - QUAD $0xfffffb611d6ffdc5 // vmovdqa $-1183(%rip), %ymm3 /* LCPI11_0(%rip) */ - QUAD $0xfffffb79256ffdc5 // vmovdqa $-1159(%rip), %ymm4 /* LCPI11_1(%rip) */ - QUAD $0xfffffb912d6ffdc5 // vmovdqa $-1135(%rip), %ymm5 /* LCPI11_2(%rip) */ - QUAD $0xfffffba9356ffdc5 // vmovdqa $-1111(%rip), %ymm6 /* LCPI11_3(%rip) */ - WORD $0xc984 // testb %cl, %cl - LONG $0xff71850f; WORD $0xffff // jne LBB11_58, $-143(%rip) + WORD $0xbc0f; BYTE $0xf0 // bsfl %eax, %esi + LONG $0x7ef9e1c4; BYTE $0xc0 // vmovq %xmm0, %rax + WORD $0x3948; BYTE $0xf1 // cmpq %rsi, %rcx + WORD $0x8949; BYTE $0xd7 // movq %rdx, %r15 + LONG $0x01938d0f; WORD $0x0000 // jge LBB7_50, $403(%rip) + LONG $0x08f98348 // cmpq $8, %rcx + LONG $0x01b8820f; WORD $0x0000 // jb LBB7_61, $440(%rip) + WORD $0x8948; BYTE $0x03 // movq %rax, (%rbx) + LONG $0x08458d49 // leaq $8(%r13), %rax + LONG $0x08c38348 // addq $8, %rbx + LONG $0xf8718d48 // leaq $-8(%rcx), %rsi + LONG $0x04fe8348 // cmpq $4, %rsi + LONG $0x01af8d0f; WORD $0x0000 // jge LBB7_64, $431(%rip) + LONG $0x0001bae9; BYTE $0x00 // jmp LBB7_65, $442(%rip) -LBB11_48: - WORD $0x854d; BYTE $0xf6 // testq %r14, %r14 - LONG $0x00768e0f; WORD $0x0000 // jle LBB11_56, $118(%rip) - WORD $0x854d; BYTE $0xed // testq %r13, %r13 - LONG $0x006d8e0f; WORD $0x0000 // jle LBB11_56, $109(%rip) - WORD $0xc931 // xorl %ecx, %ecx - WORD $0xc031 // xorl %eax, %eax - QUAD $0x9090909090909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 +LBB7_40: + WORD $0x894c; BYTE $0xd1 // movq %r10, %rcx + WORD $0x894c; BYTE $0xf0 // movq %r14, %rax + QUAD $0xfffffb601d6ffdc5 // vmovdqa $-1184(%rip), %ymm3 /* LCPI7_0(%rip) */ + QUAD $0xfffffb78256ffdc5 // vmovdqa $-1160(%rip), %ymm4 /* LCPI7_1(%rip) */ + QUAD $0xfffffb902d6ffdc5 // vmovdqa $-1136(%rip), %ymm5 /* LCPI7_2(%rip) */ + QUAD $0xfffffba8356ffdc5 // vmovdqa $-1112(%rip), %ymm6 /* LCPI7_3(%rip) */ + WORD $0x8445; BYTE $0xff // testb %r15b, %r15b + LONG $0xff6e850f; WORD $0xffff // jne LBB7_49, $-146(%rip) + +LBB7_47: + WORD $0x8548; BYTE $0xc9 // testq %rcx, %rcx + WORD $0x8949; BYTE $0xd7 // movq %rdx, %r15 + LONG $0x01a78e0f; WORD $0x0000 // jle LBB7_48, $423(%rip) + WORD $0x8948; BYTE $0xc6 // movq %rax, %rsi + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0x019e8e0f; WORD $0x0000 // jle LBB7_75, $414(%rip) + LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 -LBB11_51: - LONG $0x3cb60f41; BYTE $0x0c // movzbl (%r12,%rcx), %edi - LONG $0x3eff8348 // cmpq $62, %rdi - LONG $0x0014870f; WORD $0x0000 // ja LBB11_52, $20(%rip) - QUAD $0x004000000000ba48; WORD $0x5000 // movabsq $5764607797912141824, %rdx - LONG $0xfaa30f48 // btq %rdi, %rdx - LONG $0x0164820f; WORD $0x0000 // jb LBB11_80, $356(%rip) - -LBB11_52: - LONG $0x00e2ff81; WORD $0x0000 // cmpl $226, %edi - LONG $0x0158840f; WORD $0x0000 // je LBB11_80, $344(%rip) - LONG $0x061c8d49 // leaq (%r14,%rax), %rbx - LONG $0x083c8841 // movb %dil, (%r8,%rcx) - LONG $0xff788d48 // leaq $-1(%rax), %rdi - LONG $0x02fb8348 // cmpq $2, %rbx - LONG $0x00138c0f; WORD $0x0000 // jl LBB11_55, $19(%rip) - WORD $0x014c; BYTE $0xe8 // addq %r13, %rax - WORD $0xff48; BYTE $0xc1 // incq %rcx - LONG $0x01f88348 // cmpq $1, %rax - WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax - LONG $0xffa88f0f; WORD $0xffff // jg LBB11_51, $-88(%rip) +LBB7_71: + LONG $0x55b60f41; BYTE $0x00 // movzbl (%r13), %edx + LONG $0x3efa8348 // cmpq $62, %rdx + LONG $0x0014870f; WORD $0x0000 // ja LBB7_72, $20(%rip) + QUAD $0x004000000000be48; WORD $0x5000 // movabsq $5764607797912141824, %rsi + LONG $0xd6a30f48 // btq %rdx, %rsi + LONG $0x0121820f; WORD $0x0000 // jb LBB7_77, $289(%rip) -LBB11_55: - WORD $0x2949; BYTE $0xfc // subq %rdi, %r12 - WORD $0x0149; BYTE $0xfe // addq %rdi, %r14 +LBB7_72: + WORD $0xfa80; BYTE $0xe2 // cmpb $-30, %dl + LONG $0x0118840f; WORD $0x0000 // je LBB7_77, $280(%rip) + LONG $0xff708d48 // leaq $-1(%rax), %rsi + WORD $0xff49; BYTE $0xc5 // incq %r13 + WORD $0x1388 // movb %dl, (%rbx) + LONG $0x02f88348 // cmpq $2, %rax + LONG $0x01588c0f; WORD $0x0000 // jl LBB7_75, $344(%rip) + LONG $0xff518d48 // leaq $-1(%rcx), %rdx + WORD $0xff48; BYTE $0xc3 // incq %rbx + WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax + LONG $0x01f98348 // cmpq $1, %rcx + WORD $0x8948; BYTE $0xd1 // movq %rdx, %rcx + LONG $0xffaa8f0f; WORD $0xffff // jg LBB7_71, $-86(%rip) + LONG $0x00013ce9; BYTE $0x00 // jmp LBB7_75, $316(%rip) -LBB11_56: - WORD $0x854d; BYTE $0xf6 // testq %r14, %r14 - LONG $0x082d8d4c; WORD $0x00e7; BYTE $0x00 // leaq $59144(%rip), %r13 /* __HtmlQuoteTab(%rip) */ - LONG $0x0229840f; WORD $0x0000 // je LBB11_57, $553(%rip) - WORD $0xf749; BYTE $0xd4 // notq %r12 - WORD $0x014d; BYTE $0xdc // addq %r11, %r12 - WORD $0x854d; BYTE $0xe4 // testq %r12, %r12 - LONG $0x0233890f; WORD $0x0000 // jns LBB11_84, $563(%rip) - LONG $0x00034de9; BYTE $0x00 // jmp LBB11_83, $845(%rip) +LBB7_14: + WORD $0x894c; BYTE $0xe8 // movq %r13, %rax + WORD $0x8948; BYTE $0xce // movq %rcx, %rsi + LONG $0x08fe8348 // cmpq $8, %rsi + LONG $0x0012820f; WORD $0x0000 // jb LBB7_18, $18(%rip) -LBB11_15: - WORD $0x894d; BYTE $0xe6 // movq %r12, %r14 - WORD $0x894c; BYTE $0xd0 // movq %r10, %rax - LONG $0x08f88348 // cmpq $8, %rax - LONG $0x0012820f; WORD $0x0000 // jb LBB11_19, $18(%rip) +LBB7_17: + WORD $0x8b48; BYTE $0x10 // movq (%rax), %rdx + WORD $0x8948; BYTE $0x13 // movq %rdx, (%rbx) + LONG $0x08c08348 // addq $8, %rax + LONG $0x08c38348 // addq $8, %rbx + LONG $0xf8c68348 // addq $-8, %rsi -LBB11_18: - WORD $0x8b49; BYTE $0x0e // movq (%r14), %rcx - WORD $0x8949; BYTE $0x08 // movq %rcx, (%r8) - LONG $0x08c68349 // addq $8, %r14 - LONG $0x08c08349 // addq $8, %r8 - LONG $0xf8c08348 // addq $-8, %rax +LBB7_18: + LONG $0x04fe8348 // cmpq $4, %rsi + LONG $0x005c8d0f; WORD $0x0000 // jge LBB7_19, $92(%rip) + LONG $0x02fe8348 // cmpq $2, %rsi + LONG $0x006c830f; WORD $0x0000 // jae LBB7_21, $108(%rip) -LBB11_19: - LONG $0x04f88348 // cmpq $4, %rax - LONG $0x006c830f; WORD $0x0000 // jae LBB11_20, $108(%rip) - LONG $0x02f88348 // cmpq $2, %rax - LONG $0x007e830f; WORD $0x0000 // jae LBB11_22, $126(%rip) +LBB7_22: + WORD $0x8548; BYTE $0xf6 // testq %rsi, %rsi + LONG $0x0004840f; WORD $0x0000 // je LBB7_24, $4(%rip) -LBB11_23: - WORD $0x8548; BYTE $0xc0 // testq %rax, %rax - LONG $0x0007840f; WORD $0x0000 // je LBB11_25, $7(%rip) +LBB7_23: + WORD $0x008a // movb (%rax), %al + WORD $0x0388 // movb %al, (%rbx) -LBB11_24: - LONG $0x06b60f41 // movzbl (%r14), %eax - WORD $0x8841; BYTE $0x00 // movb %al, (%r8) +LBB7_24: + WORD $0x294d; BYTE $0xe5 // subq %r12, %r13 + WORD $0x0149; BYTE $0xcd // addq %rcx, %r13 + LONG $0x00013ee9; BYTE $0x00 // jmp LBB7_78, $318(%rip) -LBB11_25: - WORD $0x294d; BYTE $0xdc // subq %r11, %r12 - WORD $0x014d; BYTE $0xd4 // addq %r10, %r12 - WORD $0x854d; BYTE $0xe4 // testq %r12, %r12 - LONG $0x01d9890f; WORD $0x0000 // jns LBB11_84, $473(%rip) - LONG $0x0002f3e9; BYTE $0x00 // jmp LBB11_83, $755(%rip) +LBB7_31: + WORD $0x088b // movl (%rax), %ecx + WORD $0x0b89 // movl %ecx, (%rbx) + LONG $0x04c08348 // addq $4, %rax + LONG $0x04c38348 // addq $4, %rbx + LONG $0xfcc68348 // addq $-4, %rsi + LONG $0x02fe8348 // cmpq $2, %rsi + LONG $0xfe22820f; WORD $0xffff // jb LBB7_34, $-478(%rip) -LBB11_32: - WORD $0x8b41; BYTE $0x0a // movl (%r10), %ecx - WORD $0x8941; BYTE $0x08 // movl %ecx, (%r8) - LONG $0x04c28349 // addq $4, %r10 - LONG $0x04c08349 // addq $4, %r8 - LONG $0xfcc68349 // addq $-4, %r14 - LONG $0x02fe8349 // cmpq $2, %r14 - LONG $0xfde0820f; WORD $0xffff // jb LBB11_35, $-544(%rip) +LBB7_33: + WORD $0xb70f; BYTE $0x08 // movzwl (%rax), %ecx + WORD $0x8966; BYTE $0x0b // movw %cx, (%rbx) + LONG $0x02c08348 // addq $2, %rax + LONG $0x02c38348 // addq $2, %rbx + LONG $0xfec68348 // addq $-2, %rsi + WORD $0x8548; BYTE $0xf6 // testq %rsi, %rsi + LONG $0xfe10850f; WORD $0xffff // jne LBB7_35, $-496(%rip) + LONG $0xfffe0fe9; BYTE $0xff // jmp LBB7_36, $-497(%rip) -LBB11_34: - LONG $0x0ab70f41 // movzwl (%r10), %ecx - LONG $0x08894166 // movw %cx, (%r8) - LONG $0x02c28349 // addq $2, %r10 - LONG $0x02c08349 // addq $2, %r8 - LONG $0xfec68349 // addq $-2, %r14 - WORD $0x854d; BYTE $0xf6 // testq %r14, %r14 - LONG $0xfdcc850f; WORD $0xffff // jne LBB11_36, $-564(%rip) - LONG $0xfffdcee9; BYTE $0xff // jmp LBB11_37, $-562(%rip) +LBB7_19: + WORD $0x108b // movl (%rax), %edx + WORD $0x1389 // movl %edx, (%rbx) + LONG $0x04c08348 // addq $4, %rax + LONG $0x04c38348 // addq $4, %rbx + LONG $0xfcc68348 // addq $-4, %rsi + LONG $0x02fe8348 // cmpq $2, %rsi + LONG $0xff94820f; WORD $0xffff // jb LBB7_22, $-108(%rip) -LBB11_20: - WORD $0x8b41; BYTE $0x0e // movl (%r14), %ecx - WORD $0x8941; BYTE $0x08 // movl %ecx, (%r8) - LONG $0x04c68349 // addq $4, %r14 - LONG $0x04c08349 // addq $4, %r8 - LONG $0xfcc08348 // addq $-4, %rax - LONG $0x02f88348 // cmpq $2, %rax - LONG $0xff82820f; WORD $0xffff // jb LBB11_23, $-126(%rip) +LBB7_21: + WORD $0xb70f; BYTE $0x10 // movzwl (%rax), %edx + WORD $0x8966; BYTE $0x13 // movw %dx, (%rbx) + LONG $0x02c08348 // addq $2, %rax + LONG $0x02c38348 // addq $2, %rbx + LONG $0xfec68348 // addq $-2, %rsi + WORD $0x8548; BYTE $0xf6 // testq %rsi, %rsi + LONG $0xff82850f; WORD $0xffff // jne LBB7_23, $-126(%rip) + LONG $0xffff81e9; BYTE $0xff // jmp LBB7_24, $-127(%rip) -LBB11_22: - LONG $0x0eb70f41 // movzwl (%r14), %ecx - LONG $0x08894166 // movw %cx, (%r8) - LONG $0x02c68349 // addq $2, %r14 - LONG $0x02c08349 // addq $2, %r8 - LONG $0xfec08348 // addq $-2, %rax - WORD $0x8548; BYTE $0xc0 // testq %rax, %rax - LONG $0xff6e850f; WORD $0xffff // jne LBB11_24, $-146(%rip) - LONG $0xffff70e9; BYTE $0xff // jmp LBB11_25, $-144(%rip) +LBB7_50: + WORD $0xfe83; BYTE $0x08 // cmpl $8, %esi + LONG $0x0082820f; WORD $0x0000 // jb LBB7_51, $130(%rip) + WORD $0x8948; BYTE $0x03 // movq %rax, (%rbx) + LONG $0x08558d4d // leaq $8(%r13), %r10 + LONG $0x08c38348 // addq $8, %rbx + LONG $0xf8468d48 // leaq $-8(%rsi), %rax + LONG $0x04f88348 // cmpq $4, %rax + LONG $0x00798d0f; WORD $0x0000 // jge LBB7_54, $121(%rip) + LONG $0x000085e9; BYTE $0x00 // jmp LBB7_55, $133(%rip) -LBB11_59: - WORD $0xf883; BYTE $0x08 // cmpl $8, %eax - LONG $0x009c820f; WORD $0x0000 // jb LBB11_60, $156(%rip) - WORD $0x8949; BYTE $0x08 // movq %rcx, (%r8) - LONG $0x24548d4d; BYTE $0x08 // leaq $8(%r12), %r10 - LONG $0x08c08349 // addq $8, %r8 - LONG $0xf8788d48 // leaq $-8(%rax), %rdi - LONG $0xf82d8d4c; WORD $0x00e5; BYTE $0x00 // leaq $58872(%rip), %r13 /* __HtmlQuoteTab(%rip) */ - LONG $0x04ff8348 // cmpq $4, %rdi - LONG $0x0092830f; WORD $0x0000 // jae LBB11_63, $146(%rip) - LONG $0x00009fe9; BYTE $0x00 // jmp LBB11_64, $159(%rip) - -LBB11_80: - WORD $0x294d; BYTE $0xdc // subq %r11, %r12 - WORD $0x2949; BYTE $0xc4 // subq %rax, %r12 - LONG $0xdc2d8d4c; WORD $0x00e5; BYTE $0x00 // leaq $58844(%rip), %r13 /* __HtmlQuoteTab(%rip) */ - WORD $0x854d; BYTE $0xe4 // testq %r12, %r12 - LONG $0x0113890f; WORD $0x0000 // jns LBB11_84, $275(%rip) - LONG $0x00022de9; BYTE $0x00 // jmp LBB11_83, $557(%rip) +LBB7_77: + WORD $0x294d; BYTE $0xe5 // subq %r12, %r13 + LONG $0x00009be9; BYTE $0x00 // jmp LBB7_78, $155(%rip) -LBB11_70: - WORD $0x894c; BYTE $0xe0 // movq %r12, %rax - WORD $0x894c; BYTE $0xef // movq %r13, %rdi - LONG $0x04ff8348 // cmpq $4, %rdi - LONG $0x00118c0f; WORD $0x0000 // jl LBB11_74, $17(%rip) - -LBB11_73: - WORD $0x088b // movl (%rax), %ecx - WORD $0x8941; BYTE $0x08 // movl %ecx, (%r8) - LONG $0x04c08348 // addq $4, %rax - LONG $0x04c08349 // addq $4, %r8 - LONG $0xfcc78348 // addq $-4, %rdi - -LBB11_74: - LONG $0x02ff8348 // cmpq $2, %rdi - LONG $0x0087830f; WORD $0x0000 // jae LBB11_75, $135(%rip) - WORD $0x8548; BYTE $0xff // testq %rdi, %rdi - LONG $0x0006840f; WORD $0x0000 // je LBB11_78, $6(%rip) - -LBB11_77: - WORD $0xb60f; BYTE $0x00 // movzbl (%rax), %eax - WORD $0x8841; BYTE $0x00 // movb %al, (%r8) - -LBB11_78: - WORD $0x014d; BYTE $0xe5 // addq %r12, %r13 - WORD $0xf749; BYTE $0xd5 // notq %r13 - WORD $0x014d; BYTE $0xdd // addq %r11, %r13 - WORD $0x894d; BYTE $0xec // movq %r13, %r12 - LONG $0x812d8d4c; WORD $0x00e5; BYTE $0x00 // leaq $58753(%rip), %r13 /* __HtmlQuoteTab(%rip) */ - WORD $0x854d; BYTE $0xe4 // testq %r12, %r12 - LONG $0x00b8890f; WORD $0x0000 // jns LBB11_84, $184(%rip) - LONG $0x0001d2e9; BYTE $0x00 // jmp LBB11_83, $466(%rip) +LBB7_61: + WORD $0x894c; BYTE $0xe8 // movq %r13, %rax + WORD $0x8948; BYTE $0xce // movq %rcx, %rsi + LONG $0x04fe8348 // cmpq $4, %rsi + LONG $0x00108c0f; WORD $0x0000 // jl LBB7_65, $16(%rip) -LBB11_60: - WORD $0x894d; BYTE $0xe2 // movq %r12, %r10 - WORD $0x8948; BYTE $0xc7 // movq %rax, %rdi - LONG $0x662d8d4c; WORD $0x00e5; BYTE $0x00 // leaq $58726(%rip), %r13 /* __HtmlQuoteTab(%rip) */ - LONG $0x04ff8348 // cmpq $4, %rdi - LONG $0x0012820f; WORD $0x0000 // jb LBB11_64, $18(%rip) +LBB7_64: + WORD $0x108b // movl (%rax), %edx + WORD $0x1389 // movl %edx, (%rbx) + LONG $0x04c08348 // addq $4, %rax + LONG $0x04c38348 // addq $4, %rbx + LONG $0xfcc68348 // addq $-4, %rsi -LBB11_63: - WORD $0x8b41; BYTE $0x0a // movl (%r10), %ecx - WORD $0x8941; BYTE $0x08 // movl %ecx, (%r8) - LONG $0x04c28349 // addq $4, %r10 - LONG $0x04c08349 // addq $4, %r8 - LONG $0xfcc78348 // addq $-4, %rdi +LBB7_65: + LONG $0x02fe8348 // cmpq $2, %rsi + LONG $0x013e830f; WORD $0x0000 // jae LBB7_66, $318(%rip) + WORD $0x8548; BYTE $0xf6 // testq %rsi, %rsi + LONG $0x0004840f; WORD $0x0000 // je LBB7_69, $4(%rip) -LBB11_64: - LONG $0x02ff8348 // cmpq $2, %rdi - LONG $0x0045830f; WORD $0x0000 // jae LBB11_65, $69(%rip) - WORD $0x8548; BYTE $0xff // testq %rdi, %rdi - LONG $0x0007840f; WORD $0x0000 // je LBB11_68, $7(%rip) +LBB7_68: + WORD $0x008a // movb (%rax), %al + WORD $0x0388 // movb %al, (%rbx) -LBB11_67: - LONG $0x0ab60f41 // movzbl (%r10), %ecx - WORD $0x8841; BYTE $0x08 // movb %cl, (%r8) +LBB7_69: + WORD $0x294c; BYTE $0xe1 // subq %r12, %rcx + WORD $0x014c; BYTE $0xe9 // addq %r13, %rcx + WORD $0xf748; BYTE $0xd1 // notq %rcx + WORD $0x8949; BYTE $0xca // movq %rcx, %r10 + LONG $0x000056e9; BYTE $0x00 // jmp LBB7_79, $86(%rip) -LBB11_68: - WORD $0x294d; BYTE $0xdc // subq %r11, %r12 - WORD $0x0149; BYTE $0xc4 // addq %rax, %r12 - WORD $0x854d; BYTE $0xe4 // testq %r12, %r12 - LONG $0x0061890f; WORD $0x0000 // jns LBB11_84, $97(%rip) - LONG $0x00017be9; BYTE $0x00 // jmp LBB11_83, $379(%rip) +LBB7_48: + WORD $0x8948; BYTE $0xc6 // movq %rax, %rsi -LBB11_75: - WORD $0xb70f; BYTE $0x08 // movzwl (%rax), %ecx - LONG $0x08894166 // movw %cx, (%r8) - LONG $0x02c08348 // addq $2, %rax - LONG $0x02c08349 // addq $2, %r8 - LONG $0xfec78348 // addq $-2, %rdi - WORD $0x8548; BYTE $0xff // testq %rdi, %rdi - LONG $0xff66850f; WORD $0xffff // jne LBB11_77, $-154(%rip) - LONG $0xffff67e9; BYTE $0xff // jmp LBB11_78, $-153(%rip) +LBB7_75: + WORD $0x294d; BYTE $0xe5 // subq %r12, %r13 + WORD $0xf748; BYTE $0xde // negq %rsi + WORD $0x194d; BYTE $0xd2 // sbbq %r10, %r10 + WORD $0x314d; BYTE $0xea // xorq %r13, %r10 + LONG $0x000042e9; BYTE $0x00 // jmp LBB7_79, $66(%rip) -LBB11_65: - LONG $0x0ab70f41 // movzwl (%r10), %ecx - LONG $0x08894166 // movw %cx, (%r8) - LONG $0x02c28349 // addq $2, %r10 - LONG $0x02c08349 // addq $2, %r8 - LONG $0xfec78348 // addq $-2, %rdi - WORD $0x8548; BYTE $0xff // testq %rdi, %rdi - LONG $0xffa7850f; WORD $0xffff // jne LBB11_67, $-89(%rip) - LONG $0xffffa9e9; BYTE $0xff // jmp LBB11_68, $-87(%rip) +LBB7_51: + WORD $0x894d; BYTE $0xea // movq %r13, %r10 + WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax + LONG $0x04f88348 // cmpq $4, %rax + LONG $0x00118c0f; WORD $0x0000 // jl LBB7_55, $17(%rip) -LBB11_57: - WORD $0x294d; BYTE $0xdc // subq %r11, %r12 - WORD $0x854d; BYTE $0xe4 // testq %r12, %r12 - LONG $0x012c880f; WORD $0x0000 // js LBB11_83, $300(%rip) - QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 +LBB7_54: + WORD $0x8b41; BYTE $0x0a // movl (%r10), %ecx + WORD $0x0b89 // movl %ecx, (%rbx) + LONG $0x04c28349 // addq $4, %r10 + LONG $0x04c38348 // addq $4, %rbx + LONG $0xfcc08348 // addq $-4, %rax + +LBB7_55: + LONG $0x02f88348 // cmpq $2, %rax + LONG $0x0101830f; WORD $0x0000 // jae LBB7_56, $257(%rip) + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0x0005840f; WORD $0x0000 // je LBB7_59, $5(%rip) -LBB11_84: - WORD $0x014d; BYTE $0xe3 // addq %r12, %r11 - WORD $0x014d; BYTE $0xe7 // addq %r12, %r15 - WORD $0x294c; BYTE $0xe6 // subq %r12, %rsi - LONG $0x01338e0f; WORD $0x0000 // jle LBB11_85, $307(%rip) - WORD $0x294d; BYTE $0xe1 // subq %r12, %r9 - LONG $0x0bb60f41 // movzbl (%r11), %ecx +LBB7_58: + WORD $0x8a41; BYTE $0x02 // movb (%r10), %al + WORD $0x0388 // movb %al, (%rbx) + +LBB7_59: + WORD $0x294d; BYTE $0xe5 // subq %r12, %r13 + WORD $0x0149; BYTE $0xf5 // addq %rsi, %r13 + +LBB7_78: + WORD $0x894d; BYTE $0xea // movq %r13, %r10 + +LBB7_79: + WORD $0x854d; BYTE $0xd2 // testq %r10, %r10 + LONG $0x0152880f; WORD $0x0000 // js LBB7_80, $338(%rip) + WORD $0x014d; BYTE $0xd4 // addq %r10, %r12 + WORD $0x014d; BYTE $0xd0 // addq %r10, %r8 + WORD $0x294d; BYTE $0xd3 // subq %r10, %r11 + LONG $0x01668e0f; WORD $0x0000 // jle LBB7_82, $358(%rip) + WORD $0x294d; BYTE $0xd1 // subq %r10, %r9 + LONG $0x240c8a41 // movb (%r12), %cl WORD $0xf980; BYTE $0xe2 // cmpb $-30, %cl - LONG $0x00b2840f; WORD $0x0000 // je LBB11_88, $178(%rip) - WORD $0x894c; BYTE $0xd8 // movq %r11, %rax + LONG $0x00e3840f; WORD $0x0000 // je LBB7_85, $227(%rip) + WORD $0x894c; BYTE $0xe0 // movq %r12, %rax -LBB11_92: - WORD $0xb60f; BYTE $0xc9 // movzbl %cl, %ecx - LONG $0x04e1c148 // shlq $4, %rcx - LONG $0x293c8b4a // movq (%rcx,%r13), %rdi - WORD $0x6348; BYTE $0xdf // movslq %edi, %rbx - WORD $0x2949; BYTE $0xd9 // subq %rbx, %r9 - LONG $0x01208c0f; WORD $0x0000 // jl LBB11_93, $288(%rip) - LONG $0x20e7c148 // shlq $32, %rdi - WORD $0x014c; BYTE $0xe9 // addq %r13, %rcx - LONG $0x08c18348 // addq $8, %rcx - QUAD $0x000300000001ba48; WORD $0x0000 // movabsq $12884901889, %rdx - WORD $0x3948; BYTE $0xd7 // cmpq %rdx, %rdi - LONG $0x00298c0f; WORD $0x0000 // jl LBB11_97, $41(%rip) - WORD $0x398b // movl (%rcx), %edi - WORD $0x8941; BYTE $0x3f // movl %edi, (%r15) - LONG $0x04c18348 // addq $4, %rcx - LONG $0x04578d4d // leaq $4(%r15), %r10 - LONG $0xfc7b8d48 // leaq $-4(%rbx), %rdi - LONG $0x02ff8348 // cmpq $2, %rdi - LONG $0x001e830f; WORD $0x0000 // jae LBB11_100, $30(%rip) - LONG $0x00002ce9; BYTE $0x00 // jmp LBB11_101, $44(%rip) - QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90 - -LBB11_97: - WORD $0x894d; BYTE $0xfa // movq %r15, %r10 - WORD $0x8948; BYTE $0xdf // movq %rbx, %rdi - LONG $0x02ff8348 // cmpq $2, %rdi - LONG $0x0013820f; WORD $0x0000 // jb LBB11_101, $19(%rip) +LBB7_89: + WORD $0xb60f; BYTE $0xd1 // movzbl %cl, %edx + LONG $0x04e2c148 // shlq $4, %rdx + LONG $0x3a1c8b4a // movq (%rdx,%r15), %rbx + WORD $0x6348; BYTE $0xf3 // movslq %ebx, %rsi + WORD $0x2949; BYTE $0xf1 // subq %rsi, %r9 + LONG $0x01538c0f; WORD $0x0000 // jl LBB7_90, $339(%rip) + LONG $0x20e3c148 // shlq $32, %rbx + LONG $0x3a4c8d4a; BYTE $0x08 // leaq $8(%rdx,%r15), %rcx + WORD $0x3948; BYTE $0xfb // cmpq %rdi, %rbx + LONG $0x00228c0f; WORD $0x0000 // jl LBB7_94, $34(%rip) + WORD $0x098b // movl (%rcx), %ecx + WORD $0x8941; BYTE $0x08 // movl %ecx, (%r8) + LONG $0x3a4c8d4a; BYTE $0x0c // leaq $12(%rdx,%r15), %rcx + LONG $0x04588d49 // leaq $4(%r8), %rbx + LONG $0xfc568d48 // leaq $-4(%rsi), %rdx + LONG $0x02fa8348 // cmpq $2, %rdx + LONG $0x0016830f; WORD $0x0000 // jae LBB7_97, $22(%rip) + LONG $0x000029e9; BYTE $0x00 // jmp LBB7_98, $41(%rip) + BYTE $0x90 // .p2align 4, 0x90 -LBB11_100: - WORD $0xb70f; BYTE $0x11 // movzwl (%rcx), %edx - LONG $0x12894166 // movw %dx, (%r10) +LBB7_94: + WORD $0x894c; BYTE $0xc3 // movq %r8, %rbx + WORD $0x8948; BYTE $0xf2 // movq %rsi, %rdx + LONG $0x02fa8348 // cmpq $2, %rdx + LONG $0x0018820f; WORD $0x0000 // jb LBB7_98, $24(%rip) + +LBB7_97: + WORD $0x8949; BYTE $0xfa // movq %rdi, %r10 + WORD $0xb70f; BYTE $0x39 // movzwl (%rcx), %edi + WORD $0x8966; BYTE $0x3b // movw %di, (%rbx) + WORD $0x894c; BYTE $0xd7 // movq %r10, %rdi LONG $0x02c18348 // addq $2, %rcx - LONG $0x02c28349 // addq $2, %r10 - LONG $0xfec78348 // addq $-2, %rdi + LONG $0x02c38348 // addq $2, %rbx + LONG $0xfec28348 // addq $-2, %rdx -LBB11_101: - WORD $0x8548; BYTE $0xff // testq %rdi, %rdi - LONG $0x0006840f; WORD $0x0000 // je LBB11_103, $6(%rip) - WORD $0xb60f; BYTE $0x09 // movzbl (%rcx), %ecx - WORD $0x8841; BYTE $0x0a // movb %cl, (%r10) +LBB7_98: + WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx + LONG $0x0004840f; WORD $0x0000 // je LBB7_100, $4(%rip) + WORD $0x098a // movb (%rcx), %cl + WORD $0x0b88 // movb %cl, (%rbx) -LBB11_103: - WORD $0x0149; BYTE $0xdf // addq %rbx, %r15 +LBB7_100: + WORD $0x0149; BYTE $0xf0 // addq %rsi, %r8 -LBB11_104: +LBB7_101: WORD $0xff48; BYTE $0xc0 // incq %rax - LONG $0xff4e8d48 // leaq $-1(%rsi), %rcx - WORD $0x8949; BYTE $0xc3 // movq %rax, %r11 - LONG $0x01fe8348 // cmpq $1, %rsi - WORD $0x8948; BYTE $0xce // movq %rcx, %rsi - LONG $0xf8d4870f; WORD $0xffff // ja LBB11_2, $-1836(%rip) - LONG $0x000074e9; BYTE $0x00 // jmp LBB11_105, $116(%rip) - -LBB11_88: - LONG $0x03fe8348 // cmpq $3, %rsi - LONG $0x0029820f; WORD $0x0000 // jb LBB11_94, $41(%rip) - LONG $0x017b8041; BYTE $0x80 // cmpb $-128, $1(%r11) - LONG $0x001e850f; WORD $0x0000 // jne LBB11_94, $30(%rip) - LONG $0x4bb60f41; BYTE $0x02 // movzbl $2(%r11), %ecx + LONG $0xff4b8d49 // leaq $-1(%r11), %rcx + WORD $0x8949; BYTE $0xc4 // movq %rax, %r12 + LONG $0x01fb8349 // cmpq $1, %r11 + WORD $0x8949; BYTE $0xcb // movq %rcx, %r11 + LONG $0xf9a18f0f; WORD $0xffff // jg LBB7_2, $-1631(%rip) + LONG $0x0000b7e9; BYTE $0x00 // jmp LBB7_102, $183(%rip) + +LBB7_66: + WORD $0xb70f; BYTE $0x10 // movzwl (%rax), %edx + WORD $0x8966; BYTE $0x13 // movw %dx, (%rbx) + LONG $0x02c08348 // addq $2, %rax + LONG $0x02c38348 // addq $2, %rbx + LONG $0xfec68348 // addq $-2, %rsi + WORD $0x8548; BYTE $0xf6 // testq %rsi, %rsi + LONG $0xfeb0850f; WORD $0xffff // jne LBB7_68, $-336(%rip) + LONG $0xfffeafe9; BYTE $0xff // jmp LBB7_69, $-337(%rip) + +LBB7_56: + LONG $0x0ab70f41 // movzwl (%r10), %ecx + WORD $0x8966; BYTE $0x0b // movw %cx, (%rbx) + LONG $0x02c28349 // addq $2, %r10 + LONG $0x02c38348 // addq $2, %rbx + LONG $0xfec08348 // addq $-2, %rax + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0xfeec850f; WORD $0xffff // jne LBB7_58, $-276(%rip) + LONG $0xfffeece9; BYTE $0xff // jmp LBB7_59, $-276(%rip) + +LBB7_85: + LONG $0x03fb8349 // cmpq $3, %r11 + LONG $0x002b8c0f; WORD $0x0000 // jl LBB7_91, $43(%rip) + LONG $0x247c8041; WORD $0x8001 // cmpb $-128, $1(%r12) + LONG $0x001f850f; WORD $0x0000 // jne LBB7_91, $31(%rip) + LONG $0x244c8a41; BYTE $0x02 // movb $2(%r12), %cl WORD $0xc889 // movl %ecx, %eax WORD $0xfe24 // andb $-2, %al WORD $0xa83c // cmpb $-88, %al - LONG $0x000d850f; WORD $0x0000 // jne LBB11_94, $13(%rip) - LONG $0x02438d49 // leaq $2(%r11), %rax - LONG $0xfec68348 // addq $-2, %rsi - LONG $0xffff1ee9; BYTE $0xff // jmp LBB11_92, $-226(%rip) + LONG $0x000e850f; WORD $0x0000 // jne LBB7_91, $14(%rip) + LONG $0x24448d49; BYTE $0x02 // leaq $2(%r12), %rax + LONG $0xfec38349 // addq $-2, %r11 + LONG $0xfffeebe9; BYTE $0xff // jmp LBB7_89, $-277(%rip) -LBB11_94: +LBB7_91: WORD $0x854d; BYTE $0xc9 // testq %r9, %r9 - LONG $0x00578e0f; WORD $0x0000 // jle LBB11_3, $87(%rip) - LONG $0xe207c641 // movb $-30, (%r15) - WORD $0xff49; BYTE $0xc7 // incq %r15 + LONG $0x00578e0f; WORD $0x0000 // jle LBB7_3, $87(%rip) + LONG $0xe200c641 // movb $-30, (%r8) + WORD $0xff49; BYTE $0xc0 // incq %r8 WORD $0xff49; BYTE $0xc9 // decq %r9 - WORD $0x894c; BYTE $0xd8 // movq %r11, %rax - LONG $0xffff96e9; BYTE $0xff // jmp LBB11_104, $-106(%rip) + WORD $0x894c; BYTE $0xe0 // movq %r12, %rax + LONG $0xffff53e9; BYTE $0xff // jmp LBB7_101, $-173(%rip) -LBB11_83: - LONG $0xc84d8b48 // movq $-56(%rbp), %rcx - WORD $0x014c; BYTE $0xe1 // addq %r12, %rcx - WORD $0xf748; BYTE $0xd1 // notq %rcx - WORD $0x014c; BYTE $0xf9 // addq %r15, %rcx - LONG $0xc0458b48 // movq $-64(%rbp), %rax - WORD $0x8948; BYTE $0x08 // movq %rcx, (%rax) +LBB7_80: + LONG $0xc8452b4c // subq $-56(%rbp), %r8 + WORD $0x894c; BYTE $0xd0 // movq %r10, %rax + WORD $0xf748; BYTE $0xd0 // notq %rax + WORD $0x014c; BYTE $0xc0 // addq %r8, %rax + LONG $0xc04d8b48 // movq $-64(%rbp), %rcx + WORD $0x8948; BYTE $0x01 // movq %rax, (%rcx) LONG $0xd0458b48 // movq $-48(%rbp), %rax - WORD $0x294c; BYTE $0xd8 // subq %r11, %rax - WORD $0x014c; BYTE $0xe0 // addq %r12, %rax - LONG $0x00002ce9; BYTE $0x00 // jmp LBB11_106, $44(%rip) + WORD $0x294c; BYTE $0xe0 // subq %r12, %rax + WORD $0x014c; BYTE $0xd0 // addq %r10, %rax + LONG $0x00002ce9; BYTE $0x00 // jmp LBB7_103, $44(%rip) -LBB11_85: - WORD $0x894c; BYTE $0xd8 // movq %r11, %rax +LBB7_82: + WORD $0x894c; BYTE $0xe0 // movq %r12, %rax -LBB11_105: - LONG $0xc87d2b4c // subq $-56(%rbp), %r15 +LBB7_102: + LONG $0xc8452b4c // subq $-56(%rbp), %r8 LONG $0xc04d8b48 // movq $-64(%rbp), %rcx - WORD $0x894c; BYTE $0x39 // movq %r15, (%rcx) + WORD $0x894c; BYTE $0x01 // movq %r8, (%rcx) LONG $0xd0452b48 // subq $-48(%rbp), %rax - LONG $0x000015e9; BYTE $0x00 // jmp LBB11_106, $21(%rip) + LONG $0x000015e9; BYTE $0x00 // jmp LBB7_103, $21(%rip) -LBB11_93: - LONG $0xc87d2b4c // subq $-56(%rbp), %r15 +LBB7_90: + LONG $0xc8452b4c // subq $-56(%rbp), %r8 LONG $0xc0458b48 // movq $-64(%rbp), %rax - WORD $0x894c; BYTE $0x38 // movq %r15, (%rax) + WORD $0x894c; BYTE $0x00 // movq %r8, (%rax) -LBB11_3: - WORD $0xf749; BYTE $0xd3 // notq %r11 - LONG $0xd05d034c // addq $-48(%rbp), %r11 - WORD $0x894c; BYTE $0xd8 // movq %r11, %rax +LBB7_3: + WORD $0xf749; BYTE $0xd4 // notq %r12 + LONG $0xd065034c // addq $-48(%rbp), %r12 + WORD $0x894c; BYTE $0xe0 // movq %r12, %rax -LBB11_106: - LONG $0x18c48348 // addq $24, %rsp - BYTE $0x5b // popq %rbx - WORD $0x5c41 // popq %r12 - WORD $0x5d41 // popq %r13 - WORD $0x5e41 // popq %r14 - WORD $0x5f41 // popq %r15 - BYTE $0x5d // popq %rbp - WORD $0xf8c5; BYTE $0x77 // vzeroupper - BYTE $0xc3 // retq +LBB7_103: + LONG $0x18c48348 // addq $24, %rsp + BYTE $0x5b // popq %rbx + WORD $0x5c41 // popq %r12 + WORD $0x5d41 // popq %r13 + WORD $0x5e41 // popq %r14 + WORD $0x5f41 // popq %r15 + BYTE $0x5d // popq %rbp + WORD $0xf8c5; BYTE $0x77 // vzeroupper + BYTE $0xc3 // retq + QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90 - // .p2align 4, 0x90 _atof_eisel_lemire64: BYTE $0x55 // pushq %rbp WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp WORD $0x5741 // pushq %r15 WORD $0x5641 // pushq %r14 - WORD $0x5441 // pushq %r12 BYTE $0x53 // pushq %rbx - LONG $0xfea4868d; WORD $0xffff // leal $-348(%rsi), %eax - LONG $0xfffd483d; BYTE $0xff // cmpl $-696, %eax - LONG $0x0122820f; WORD $0x0000 // jb LBB12_1, $290(%rip) + LONG $0x015c868d; WORD $0x0000 // leal $348(%rsi), %eax + LONG $0x0002b73d; BYTE $0x00 // cmpl $695, %eax + LONG $0x0115870f; WORD $0x0000 // ja LBB8_1, $277(%rip) WORD $0x8949; BYTE $0xc8 // movq %rcx, %r8 WORD $0x8941; BYTE $0xd1 // movl %edx, %r9d WORD $0x8548; BYTE $0xff // testq %rdi, %rdi - LONG $0x000d840f; WORD $0x0000 // je LBB12_4, $13(%rip) + LONG $0x000d840f; WORD $0x0000 // je LBB8_4, $13(%rip) LONG $0xd7bd0f4c // bsrq %rdi, %r10 LONG $0x3ff28349 // xorq $63, %r10 - LONG $0x000006e9; BYTE $0x00 // jmp LBB12_5, $6(%rip) + LONG $0x000006e9; BYTE $0x00 // jmp LBB8_5, $6(%rip) -LBB12_4: +LBB8_4: LONG $0x0040ba41; WORD $0x0000 // movl $64, %r10d -LBB12_5: +LBB8_5: WORD $0x8944; BYTE $0xd1 // movl %r10d, %ecx WORD $0xd348; BYTE $0xe7 // shlq %cl, %rdi - LONG $0x015c8e8d; WORD $0x0000 // leal $348(%rsi), %ecx - LONG $0x04e1c148 // shlq $4, %rcx - LONG $0x3b258d4c; WORD $0x006d; BYTE $0x00 // leaq $27963(%rip), %r12 /* _POW10_M128_TAB(%rip) */ + WORD $0xc389 // movl %eax, %ebx + LONG $0x04e3c148 // shlq $4, %rbx + LONG $0x01358d4c; WORD $0x0069; BYTE $0x00 // leaq $26881(%rip), %r14 /* _POW10_M128_TAB(%rip) */ WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax - LONG $0x2164f74a; BYTE $0x08 // mulq $8(%rcx,%r12) + LONG $0x3364f74a; BYTE $0x08 // mulq $8(%rbx,%r14) WORD $0x8949; BYTE $0xc7 // movq %rax, %r15 WORD $0x8949; BYTE $0xd3 // movq %rdx, %r11 - WORD $0x8944; BYTE $0xdb // movl %r11d, %ebx - LONG $0x01ffe381; WORD $0x0000 // andl $511, %ebx - LONG $0xfffb8148; WORD $0x0001; BYTE $0x00 // cmpq $511, %rbx - LONG $0x0050850f; WORD $0x0000 // jne LBB12_11, $80(%rip) - WORD $0x8949; BYTE $0xfe // movq %rdi, %r14 - WORD $0xf749; BYTE $0xd6 // notq %r14 + WORD $0x8944; BYTE $0xd8 // movl %r11d, %eax + LONG $0x0001ff25; BYTE $0x00 // andl $511, %eax + WORD $0x8948; BYTE $0xf9 // movq %rdi, %rcx + WORD $0xf748; BYTE $0xd1 // notq %rcx + WORD $0x3949; BYTE $0xcf // cmpq %rcx, %r15 + LONG $0x004f860f; WORD $0x0000 // jbe LBB8_11, $79(%rip) WORD $0x894c; BYTE $0xfa // movq %r15, %rdx - WORD $0x394d; BYTE $0xf7 // cmpq %r14, %r15 - LONG $0x0041860f; WORD $0x0000 // jbe LBB12_13, $65(%rip) + LONG $0x0001ff3d; BYTE $0x00 // cmpl $511, %eax + LONG $0x0044850f; WORD $0x0000 // jne LBB8_13, $68(%rip) WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax - LONG $0x2124f74a // mulq (%rcx,%r12) + LONG $0x3324f74a // mulq (%rbx,%r14) WORD $0x014c; BYTE $0xfa // addq %r15, %rdx LONG $0x00d38349 // adcq $0, %r11 - WORD $0x8944; BYTE $0xd9 // movl %r11d, %ecx - WORD $0xd1f7 // notl %ecx - LONG $0x37e1c148 // shlq $55, %rcx - LONG $0x0013850f; WORD $0x0000 // jne LBB12_12, $19(%rip) + WORD $0x3948; BYTE $0xc8 // cmpq %rcx, %rax + LONG $0x001d860f; WORD $0x0000 // jbe LBB8_12, $29(%rip) LONG $0xfffa8348 // cmpq $-1, %rdx - LONG $0x0009850f; WORD $0x0000 // jne LBB12_12, $9(%rip) - WORD $0x394c; BYTE $0xf0 // cmpq %r14, %rax - LONG $0x0083870f; WORD $0x0000 // ja LBB12_1, $131(%rip) - -LBB12_12: - WORD $0x8944; BYTE $0xdb // movl %r11d, %ebx - LONG $0x01ffe381; WORD $0x0000 // andl $511, %ebx - LONG $0x000003e9; BYTE $0x00 // jmp LBB12_13, $3(%rip) - -LBB12_11: + LONG $0x0013850f; WORD $0x0000 // jne LBB8_12, $19(%rip) + WORD $0x8944; BYTE $0xd8 // movl %r11d, %eax + LONG $0x0001ff25; BYTE $0x00 // andl $511, %eax + LONG $0x0001ff3d; BYTE $0x00 // cmpl $511, %eax + LONG $0x0079840f; WORD $0x0000 // je LBB8_1, $121(%rip) + +LBB8_12: + WORD $0x8944; BYTE $0xd8 // movl %r11d, %eax + LONG $0x0001ff25; BYTE $0x00 // andl $511, %eax + LONG $0x000003e9; BYTE $0x00 // jmp LBB8_13, $3(%rip) + +LBB8_11: WORD $0x894c; BYTE $0xfa // movq %r15, %rdx -LBB12_13: - WORD $0x894c; BYTE $0xd8 // movq %r11, %rax - LONG $0x3fe8c148 // shrq $63, %rax - WORD $0x488d; BYTE $0x09 // leal $9(%rax), %ecx +LBB8_13: + WORD $0x894c; BYTE $0xdf // movq %r11, %rdi + LONG $0x3fefc148 // shrq $63, %rdi + WORD $0x4f8d; BYTE $0x09 // leal $9(%rdi), %ecx WORD $0xd349; BYTE $0xeb // shrq %cl, %r11 - WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx - LONG $0x0018850f; WORD $0x0000 // jne LBB12_17, $24(%rip) - WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx - LONG $0x000f850f; WORD $0x0000 // jne LBB12_17, $15(%rip) - WORD $0x8944; BYTE $0xd9 // movl %r11d, %ecx - WORD $0xe183; BYTE $0x03 // andl $3, %ecx - WORD $0xf983; BYTE $0x01 // cmpl $1, %ecx - LONG $0x0044840f; WORD $0x0000 // je LBB12_1, $68(%rip) - -LBB12_17: - LONG $0x526ace69; WORD $0x0003 // imull $217706, %esi, %ecx - WORD $0xf9c1; BYTE $0x10 // sarl $16, %ecx - LONG $0x043fc181; WORD $0x0000 // addl $1087, %ecx - WORD $0x6348; BYTE $0xf1 // movslq %ecx, %rsi - WORD $0x294c; BYTE $0xd6 // subq %r10, %rsi - WORD $0x8944; BYTE $0xda // movl %r11d, %edx - WORD $0xe283; BYTE $0x01 // andl $1, %edx - WORD $0x014c; BYTE $0xda // addq %r11, %rdx - WORD $0x8948; BYTE $0xd1 // movq %rdx, %rcx - LONG $0x36e9c148 // shrq $54, %rcx - WORD $0x0148; BYTE $0xf0 // addq %rsi, %rax + WORD $0x0948; BYTE $0xd0 // orq %rdx, %rax + LONG $0x000f850f; WORD $0x0000 // jne LBB8_16, $15(%rip) + WORD $0x8944; BYTE $0xd8 // movl %r11d, %eax + WORD $0xe083; BYTE $0x03 // andl $3, %eax + WORD $0xf883; BYTE $0x01 // cmpl $1, %eax + LONG $0x0044840f; WORD $0x0000 // je LBB8_1, $68(%rip) + +LBB8_16: + LONG $0x526ac669; WORD $0x0003 // imull $217706, %esi, %eax + WORD $0xf8c1; BYTE $0x10 // sarl $16, %eax + LONG $0x00043f05; BYTE $0x00 // addl $1087, %eax + WORD $0x6348; BYTE $0xd0 // movslq %eax, %rdx + WORD $0x8944; BYTE $0xd8 // movl %r11d, %eax + WORD $0xe083; BYTE $0x01 // andl $1, %eax + WORD $0x014c; BYTE $0xd8 // addq %r11, %rax + QUAD $0x000000000000b948; WORD $0x01c0 // movabsq $126100789566373888, %rcx + WORD $0x2148; BYTE $0xc1 // andq %rax, %rcx + WORD $0x294c; BYTE $0xd2 // subq %r10, %rdx + LONG $0x3a548d48; BYTE $0xfe // leaq $-2(%rdx,%rdi), %rdx LONG $0x01f98348 // cmpq $1, %rcx - LONG $0x00d88348 // sbbq $0, %rax - LONG $0x01b08d48; WORD $0xfff8; BYTE $0xff // leaq $-2047(%rax), %rsi - LONG $0x02fe8148; WORD $0xfff8; BYTE $0xff // cmpq $-2046, %rsi - LONG $0x000b830f; WORD $0x0000 // jae LBB12_19, $11(%rip) + LONG $0xffda8348 // sbbq $-1, %rdx + LONG $0xfdfa8148; WORD $0x0007; BYTE $0x00 // cmpq $2045, %rdx + LONG $0x0009860f; WORD $0x0000 // jbe LBB8_18, $9(%rip) -LBB12_1: +LBB8_1: WORD $0xc031 // xorl %eax, %eax -LBB12_20: +LBB8_19: BYTE $0x5b // popq %rbx - WORD $0x5c41 // popq %r12 WORD $0x5e41 // popq %r14 WORD $0x5f41 // popq %r15 BYTE $0x5d // popq %rbp BYTE $0xc3 // retq -LBB12_19: - LONG $0x01f98348 // cmpq $1, %rcx - WORD $0x02b1 // movb $2, %cl - WORD $0xd980; BYTE $0x00 // sbbb $0, %cl - WORD $0xd348; BYTE $0xea // shrq %cl, %rdx - LONG $0x34e0c148 // shlq $52, %rax - QUAD $0xffffffffffffb948; WORD $0x000f // movabsq $4503599627370495, %rcx - WORD $0x2148; BYTE $0xd1 // andq %rdx, %rcx - WORD $0x0948; BYTE $0xc1 // orq %rax, %rcx - QUAD $0x000000000000b848; WORD $0x8000 // movabsq $-9223372036854775808, %rax - WORD $0x0948; BYTE $0xc8 // orq %rcx, %rax - LONG $0xfff98341 // cmpl $-1, %r9d - LONG $0xc1450f48 // cmovneq %rcx, %rax - WORD $0x8949; BYTE $0x00 // movq %rax, (%r8) - WORD $0x01b0 // movb $1, %al - LONG $0xffffb8e9; BYTE $0xff // jmp LBB12_20, $-72(%rip) - QUAD $0x0000000000000000 // .p2align 5, 0x00 - -LCPI13_0: +LBB8_18: + WORD $0xff48; BYTE $0xc2 // incq %rdx + LONG $0x01f98348 // cmpq $1, %rcx + WORD $0x02b1 // movb $2, %cl + WORD $0xd980; BYTE $0x00 // sbbb $0, %cl + WORD $0xd348; BYTE $0xe8 // shrq %cl, %rax + LONG $0x34e2c148 // shlq $52, %rdx + QUAD $0xffffffffffffb948; WORD $0x000f // movabsq $4503599627370495, %rcx + WORD $0x2148; BYTE $0xc1 // andq %rax, %rcx + WORD $0x0948; BYTE $0xd1 // orq %rdx, %rcx + QUAD $0x000000000000b848; WORD $0x8000 // movabsq $-9223372036854775808, %rax + WORD $0x0948; BYTE $0xc8 // orq %rcx, %rax + LONG $0xfff98341 // cmpl $-1, %r9d + LONG $0xc1450f48 // cmovneq %rcx, %rax + WORD $0x8949; BYTE $0x00 // movq %rax, (%r8) + WORD $0x01b0 // movb $1, %al + LONG $0xffffb7e9; BYTE $0xff // jmp LBB8_19, $-73(%rip) + QUAD $0x0000000000000000; QUAD $0x0000000000000000; LONG $0x00000000; WORD $0x0000 // .p2align 5, 0x00 + +LCPI9_0: QUAD $0x0000000000000000 // .space 8, '\x00\x00\x00\x00\x00\x00\x00\x00' QUAD $0x0000000000000001 // .quad 1 QUAD $0x0000000000000001 // .quad 1 QUAD $0x0000000000000001 // .quad 1 // .p2align 3, 0x00 -LCPI13_1: +LCPI9_1: QUAD $0x0000000000000001 // .quad 1 -LCPI13_2: +LCPI9_2: QUAD $0x0000000000002710 // .quad 10000 -LCPI13_3: +LCPI9_3: QUAD $0x000000000000000a // .quad 10 QUAD $0x9090909090909090 // .p2align 4, 0x90 @@ -4014,223 +3700,195 @@ _decimal_to_f64: WORD $0x8949; BYTE $0xff // movq %rdi, %r15 QUAD $0x000000000000bd49; WORD $0x0010 // movabsq $4503599627370496, %r13 LONG $0x00107f83 // cmpl $0, $16(%rdi) - LONG $0x0021840f; WORD $0x0000 // je LBB13_3, $33(%rip) + LONG $0x002f840f; WORD $0x0000 // je LBB9_4, $47(%rip) + QUAD $0x000000000000be49; WORD $0x7ff0 // movabsq $9218868437227405312, %r14 LONG $0x14478b41 // movl $20(%r15), %eax - LONG $0x0001363d; BYTE $0x00 // cmpl $310, %eax - LONG $0x001d8e0f; WORD $0x0000 // jle LBB13_4, $29(%rip) - -LBB13_2: WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d - QUAD $0x000000000000be49; WORD $0x7ff0 // movabsq $9218868437227405312, %r14 - LONG $0x000566e9; BYTE $0x00 // jmp LBB13_74, $1382(%rip) + LONG $0x0001363d; BYTE $0x00 // cmpl $310, %eax + LONG $0x052b8f0f; WORD $0x0000 // jg LBB9_69, $1323(%rip) + LONG $0xfffeb63d; BYTE $0xff // cmpl $-330, %eax + LONG $0x00138d0f; WORD $0x0000 // jge LBB9_5, $19(%rip) + WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d + LONG $0x000518e9; BYTE $0x00 // jmp LBB9_69, $1304(%rip) -LBB13_3: +LBB9_4: WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d - LONG $0x00055be9; BYTE $0x00 // jmp LBB13_74, $1371(%rip) - -LBB13_4: - WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d - LONG $0xfffeb63d; BYTE $0xff // cmpl $-330, %eax - LONG $0x00088d0f; WORD $0x0000 // jge LBB13_6, $8(%rip) - WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d - LONG $0x000545e9; BYTE $0x00 // jmp LBB13_74, $1349(%rip) + LONG $0x00050de9; BYTE $0x00 // jmp LBB9_69, $1293(%rip) -LBB13_6: - WORD $0xc085 // testl %eax, %eax - LONG $0xd05d8948 // movq %rbx, $-48(%rbp) - LONG $0x00aa8e0f; WORD $0x0000 // jle LBB13_17, $170(%rip) - WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d - LONG $0xd0358d4c; WORD $0x0096; BYTE $0x00 // leaq $38608(%rip), %r14 /* _POW_TAB(%rip) */ - LONG $0x000039e9; BYTE $0x00 // jmp LBB13_11, $57(%rip) - QUAD $0x9090909090909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 +LBB9_5: + WORD $0xc085 // testl %eax, %eax + LONG $0xd05d8948 // movq %rbx, $-48(%rbp) + LONG $0x005a8e0f; WORD $0x0000 // jle LBB9_12, $90(%rip) + WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d + LONG $0x98358d4c; WORD $0x0092; BYTE $0x00 // leaq $37528(%rip), %r14 /* _POW_TAB(%rip) */ + LONG $0x00002de9; BYTE $0x00 // jmp LBB9_8, $45(%rip) + WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 -LBB13_8: - LONG $0xffffe5be; BYTE $0xff // movl $-27, %esi - LONG $0x00001bbb; BYTE $0x00 // movl $27, %ebx +LBB9_10: + WORD $0xc089 // movl %eax, %eax + LONG $0x861c8b41 // movl (%r14,%rax,4), %ebx LONG $0x107f8341; BYTE $0x00 // cmpl $0, $16(%r15) - LONG $0x000a840f; WORD $0x0000 // je LBB13_10, $10(%rip) + LONG $0x000a840f; WORD $0x0000 // je LBB9_7, $10(%rip) -LBB13_9: - WORD $0xdef7 // negl %esi +LBB9_11: WORD $0x894c; BYTE $0xff // movq %r15, %rdi - LONG $0x006301e8; BYTE $0x00 // callq _right_shift, $25345(%rip) + WORD $0xde89 // movl %ebx, %esi + LONG $0x006225e8; BYTE $0x00 // callq _right_shift, $25125(%rip) -LBB13_10: +LBB9_7: WORD $0x0141; BYTE $0xdc // addl %ebx, %r12d LONG $0x14478b41 // movl $20(%r15), %eax WORD $0xc085 // testl %eax, %eax - LONG $0x00628e0f; WORD $0x0000 // jle LBB13_17, $98(%rip) + LONG $0x001e8e0f; WORD $0x0000 // jle LBB9_12, $30(%rip) -LBB13_11: +LBB9_8: WORD $0xf883; BYTE $0x08 // cmpl $8, %eax - LONG $0xffc9870f; WORD $0xffff // ja LBB13_8, $-55(%rip) - WORD $0xc089 // movl %eax, %eax - LONG $0x861c8b41 // movl (%r14,%rax,4), %ebx + LONG $0xffcd8e0f; WORD $0xffff // jle LBB9_10, $-51(%rip) + LONG $0x00001bbb; BYTE $0x00 // movl $27, %ebx LONG $0x107f8341; BYTE $0x00 // cmpl $0, $16(%r15) - LONG $0xffd7840f; WORD $0xffff // je LBB13_10, $-41(%rip) - WORD $0xde89 // movl %ebx, %esi - WORD $0xdef7 // negl %esi - WORD $0xfe83; BYTE $0xc3 // cmpl $-61, %esi - LONG $0xffc0870f; WORD $0xffff // ja LBB13_9, $-64(%rip) - WORD $0x894d; BYTE $0xf5 // movq %r14, %r13 - QUAD $0x9090909090909090 // .p2align 4, 0x90 - -LBB13_15: - WORD $0x8941; BYTE $0xf6 // movl %esi, %r14d - WORD $0x894c; BYTE $0xff // movq %r15, %rdi - LONG $0x00003cbe; BYTE $0x00 // movl $60, %esi - LONG $0x0062b0e8; BYTE $0x00 // callq _right_shift, $25264(%rip) - LONG $0x3c768d41 // leal $60(%r14), %esi - LONG $0x88fe8341 // cmpl $-120, %r14d - LONG $0xffe2820f; WORD $0xffff // jb LBB13_15, $-30(%rip) - WORD $0x894d; BYTE $0xee // movq %r13, %r14 - QUAD $0x000000000000bd49; WORD $0x0010 // movabsq $4503599627370496, %r13 - LONG $0xffff85e9; BYTE $0xff // jmp LBB13_9, $-123(%rip) + LONG $0xffce850f; WORD $0xffff // jne LBB9_11, $-50(%rip) + LONG $0xffffd3e9; BYTE $0xff // jmp LBB9_7, $-45(%rip) -LBB13_17: - LONG $0x29358d4c; WORD $0x0096; BYTE $0x00 // leaq $38441(%rip), %r14 /* _POW_TAB(%rip) */ - LONG $0x000025e9; BYTE $0x00 // jmp LBB13_19, $37(%rip) +LBB9_12: + LONG $0x41358d4c; WORD $0x0092; BYTE $0x00 // leaq $37441(%rip), %r14 /* _POW_TAB(%rip) */ + LONG $0x00002de9; BYTE $0x00 // jmp LBB9_14, $45(%rip) -LBB13_23: - LONG $0x00001bbb; BYTE $0x00 // movl $27, %ebx - LONG $0x107f8341; BYTE $0x00 // cmpl $0, $16(%r15) - LONG $0x0012840f; WORD $0x0000 // je LBB13_18, $18(%rip) - LONG $0x90909090 // .p2align 4, 0x90 +LBB9_18: + LONG $0x00001bbb; BYTE $0x00 // movl $27, %ebx + LONG $0x107f8341; BYTE $0x00 // cmpl $0, $16(%r15) + LONG $0x001a840f; WORD $0x0000 // je LBB9_13, $26(%rip) + QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90 -LBB13_25: +LBB9_20: WORD $0x894c; BYTE $0xff // movq %r15, %rdi WORD $0xde89 // movl %ebx, %esi - LONG $0x006076e8; BYTE $0x00 // callq _left_shift, $24694(%rip) + LONG $0x005fd6e8; BYTE $0x00 // callq _left_shift, $24534(%rip) LONG $0x14478b41 // movl $20(%r15), %eax -LBB13_18: +LBB9_13: WORD $0x2941; BYTE $0xdc // subl %ebx, %r12d -LBB13_19: +LBB9_14: WORD $0xc085 // testl %eax, %eax - LONG $0x0017880f; WORD $0x0000 // js LBB13_22, $23(%rip) - LONG $0x0032850f; WORD $0x0000 // jne LBB13_26, $50(%rip) + LONG $0x0017880f; WORD $0x0000 // js LBB9_17, $23(%rip) + LONG $0x0035850f; WORD $0x0000 // jne LBB9_21, $53(%rip) WORD $0x8b49; BYTE $0x0f // movq (%r15), %rcx WORD $0x3980; BYTE $0x35 // cmpb $53, (%rcx) - LONG $0x000e8c0f; WORD $0x0000 // jl LBB13_24, $14(%rip) - LONG $0x000021e9; BYTE $0x00 // jmp LBB13_26, $33(%rip) + LONG $0x000e8c0f; WORD $0x0000 // jl LBB9_19, $14(%rip) + LONG $0x000024e9; BYTE $0x00 // jmp LBB9_21, $36(%rip) // .p2align 4, 0x90 -LBB13_22: +LBB9_17: WORD $0xf883; BYTE $0xf8 // cmpl $-8, %eax - LONG $0xffb3820f; WORD $0xffff // jb LBB13_23, $-77(%rip) + LONG $0xffab8c0f; WORD $0xffff // jl LBB9_18, $-85(%rip) -LBB13_24: +LBB9_19: WORD $0xc189 // movl %eax, %ecx WORD $0xd9f7 // negl %ecx + WORD $0x6348; BYTE $0xc9 // movslq %ecx, %rcx LONG $0x8e1c8b41 // movl (%r14,%rcx,4), %ebx LONG $0x107f8341; BYTE $0x00 // cmpl $0, $16(%r15) - LONG $0xffb4850f; WORD $0xffff // jne LBB13_25, $-76(%rip) - LONG $0xffffbde9; BYTE $0xff // jmp LBB13_18, $-67(%rip) - -LBB13_26: - LONG $0x02fc8141; WORD $0xfffc; BYTE $0xff // cmpl $-1022, %r12d - LONG $0x00568f0f; WORD $0x0000 // jg LBB13_32, $86(%rip) - LONG $0x107f8341; BYTE $0x00 // cmpl $0, $16(%r15) - LONG $0xd05d8b48 // movq $-48(%rbp), %rbx - LONG $0x0075840f; WORD $0x0000 // je LBB13_35, $117(%rip) - LONG $0xc6fc8141; WORD $0xfffb; BYTE $0xff // cmpl $-1082, %r12d - LONG $0x0073870f; WORD $0x0000 // ja LBB13_36, $115(%rip) - LONG $0xc1c48141; WORD $0x0003; BYTE $0x00 // addl $961, %r12d - QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + LONG $0xffb1850f; WORD $0xffff // jne LBB9_20, $-79(%rip) + LONG $0xffffbae9; BYTE $0xff // jmp LBB9_13, $-70(%rip) -LBB13_30: +LBB9_21: + LONG $0x02fc8141; WORD $0xfffc; BYTE $0xff // cmpl $-1022, %r12d + LONG $0x00538f0f; WORD $0x0000 // jg LBB9_27, $83(%rip) + LONG $0x107f8341; BYTE $0x00 // cmpl $0, $16(%r15) + LONG $0xd05d8b48 // movq $-48(%rbp), %rbx + LONG $0x0060840f; WORD $0x0000 // je LBB9_29, $96(%rip) + LONG $0xc6fc8141; WORD $0xfffb; BYTE $0xff // cmpl $-1082, %r12d + LONG $0x005e8f0f; WORD $0x0000 // jg LBB9_30, $94(%rip) + LONG $0xc1c48141; WORD $0x0003; BYTE $0x00 // addl $961, %r12d + QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90 + +LBB9_25: WORD $0x894c; BYTE $0xff // movq %r15, %rdi LONG $0x00003cbe; BYTE $0x00 // movl $60, %esi - LONG $0x0061d3e8; BYTE $0x00 // callq _right_shift, $25043(%rip) + LONG $0x006133e8; BYTE $0x00 // callq _right_shift, $24883(%rip) LONG $0x3cc48341 // addl $60, %r12d LONG $0x88fc8341 // cmpl $-120, %r12d - LONG $0xffe5820f; WORD $0xffff // jb LBB13_30, $-27(%rip) + LONG $0xffe58c0f; WORD $0xffff // jl LBB9_25, $-27(%rip) LONG $0x3cc48341 // addl $60, %r12d - LONG $0x000040e9; BYTE $0x00 // jmp LBB13_37, $64(%rip) + LONG $0x00002ee9; BYTE $0x00 // jmp LBB9_31, $46(%rip) -LBB13_32: +LBB9_27: LONG $0x00fc8141; WORD $0x0004; BYTE $0x00 // cmpl $1024, %r12d LONG $0xd05d8b48 // movq $-48(%rbp), %rbx - QUAD $0x000000000000be49; WORD $0x7ff0 // movabsq $9218868437227405312, %r14 - LONG $0x00088e0f; WORD $0x0000 // jle LBB13_34, $8(%rip) - WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d - LONG $0x000398e9; BYTE $0x00 // jmp LBB13_74, $920(%rip) - -LBB13_34: - WORD $0xff41; BYTE $0xcc // decl %r12d - WORD $0x8945; BYTE $0xe6 // movl %r12d, %r14d - LONG $0x000026e9; BYTE $0x00 // jmp LBB13_38, $38(%rip) + LONG $0x03838f0f; WORD $0x0000 // jg LBB9_66, $899(%rip) + WORD $0xff41; BYTE $0xcc // decl %r12d + WORD $0x8945; BYTE $0xe6 // movl %r12d, %r14d + LONG $0x000026e9; BYTE $0x00 // jmp LBB9_32, $38(%rip) -LBB13_35: +LBB9_29: LONG $0xfc02be41; WORD $0xffff // movl $-1022, %r14d - LONG $0x000033e9; BYTE $0x00 // jmp LBB13_40, $51(%rip) + LONG $0x000033e9; BYTE $0x00 // jmp LBB9_34, $51(%rip) -LBB13_36: +LBB9_30: LONG $0xfdc48141; WORD $0x0003; BYTE $0x00 // addl $1021, %r12d -LBB13_37: +LBB9_31: WORD $0xf741; BYTE $0xdc // negl %r12d WORD $0x894c; BYTE $0xff // movq %r15, %rdi WORD $0x8944; BYTE $0xe6 // movl %r12d, %esi - LONG $0x00616ee8; BYTE $0x00 // callq _right_shift, $24942(%rip) + LONG $0x0060e0e8; BYTE $0x00 // callq _right_shift, $24800(%rip) LONG $0xfc02be41; WORD $0xffff // movl $-1022, %r14d -LBB13_38: +LBB9_32: LONG $0x107f8341; BYTE $0x00 // cmpl $0, $16(%r15) - LONG $0x000d840f; WORD $0x0000 // je LBB13_40, $13(%rip) + LONG $0x000d840f; WORD $0x0000 // je LBB9_34, $13(%rip) WORD $0x894c; BYTE $0xff // movq %r15, %rdi LONG $0x000035be; BYTE $0x00 // movl $53, %esi - LONG $0x005f60e8; BYTE $0x00 // callq _left_shift, $24416(%rip) + LONG $0x005ed2e8; BYTE $0x00 // callq _left_shift, $24274(%rip) -LBB13_40: +LBB9_34: LONG $0x14478b41 // movl $20(%r15), %eax LONG $0xffc4c749; WORD $0xffff; BYTE $0xff // movq $-1, %r12 WORD $0xf883; BYTE $0x14 // cmpl $20, %eax - LONG $0x031c8f0f; WORD $0x0000 // jg LBB13_73, $796(%rip) + LONG $0x033e8f0f; WORD $0x0000 // jg LBB9_68, $830(%rip) WORD $0xc085 // testl %eax, %eax - LONG $0x00558e0f; WORD $0x0000 // jle LBB13_46, $85(%rip) + LONG $0x00548e0f; WORD $0x0000 // jle LBB9_40, $84(%rip) LONG $0x10578b41 // movl $16(%r15), %edx WORD $0xf631 // xorl %esi, %esi WORD $0xd285 // testl %edx, %edx - WORD $0x4e0f; BYTE $0xd6 // cmovlel %esi, %edx + WORD $0x480f; BYTE $0xd6 // cmovsl %esi, %edx LONG $0xff488d4c // leaq $-1(%rax), %r9 WORD $0x3949; BYTE $0xd1 // cmpq %rdx, %r9 - LONG $0xca430f4c // cmovaeq %rdx, %r9 - LONG $0x01418d4d // leaq $1(%r9), %r8 + LONG $0xca430f44 // cmovael %edx, %r9d + LONG $0x01418d45 // leal $1(%r9), %r8d WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d - LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90 -LBB13_43: +LBB9_37: WORD $0x3948; BYTE $0xf2 // cmpq %rsi, %rdx - LONG $0x002e840f; WORD $0x0000 // je LBB13_47, $46(%rip) + LONG $0x002b840f; WORD $0x0000 // je LBB9_41, $43(%rip) LONG $0xa43c8d4b // leaq (%r12,%r12,4), %rdi WORD $0x8b49; BYTE $0x0f // movq (%r15), %rcx LONG $0x0cbe0f48; BYTE $0x31 // movsbq (%rcx,%rsi), %rcx - LONG $0x79248d4c // leaq (%rcx,%rdi,2), %r12 - LONG $0xd0c48349 // addq $-48, %r12 + LONG $0x79648d4c; BYTE $0xd0 // leaq $-48(%rcx,%rdi,2), %r12 WORD $0xff48; BYTE $0xc6 // incq %rsi WORD $0x3948; BYTE $0xf0 // cmpq %rsi, %rax - LONG $0xffd7850f; WORD $0xffff // jne LBB13_43, $-41(%rip) - WORD $0x894d; BYTE $0xc1 // movq %r8, %r9 - LONG $0x000006e9; BYTE $0x00 // jmp LBB13_47, $6(%rip) + LONG $0xffda850f; WORD $0xffff // jne LBB9_37, $-38(%rip) + WORD $0x8945; BYTE $0xc1 // movl %r8d, %r9d + LONG $0x000006e9; BYTE $0x00 // jmp LBB9_41, $6(%rip) -LBB13_46: +LBB9_40: WORD $0x3145; BYTE $0xc9 // xorl %r9d, %r9d WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d -LBB13_47: +LBB9_41: WORD $0x3944; BYTE $0xc8 // cmpl %r9d, %eax - LONG $0x022f8e0f; WORD $0x0000 // jle LBB13_60, $559(%rip) + LONG $0x02428e0f; WORD $0x0000 // jle LBB9_54, $578(%rip) WORD $0xc289 // movl %eax, %edx WORD $0x2944; BYTE $0xca // subl %r9d, %edx WORD $0xfa83; BYTE $0x10 // cmpl $16, %edx - LONG $0x020d820f; WORD $0x0000 // jb LBB13_58, $525(%rip) + LONG $0x0220820f; WORD $0x0000 // jb LBB9_52, $544(%rip) WORD $0x8941; BYTE $0xd0 // movl %edx, %r8d - LONG $0x6ef9c1c4; BYTE $0xc4 // vmovq %r12, %xmm0 - QUAD $0xfffcc005027de3c4; WORD $0xfcff // vpblendd $252, $-832(%rip), %ymm0, %ymm0 /* LCPI13_0(%rip) */ + QUAD $0xfffffd2a056ff9c5 // vmovdqa $-726(%rip), %xmm0 /* LCPI9_0(%rip) */ + LONG $0x22f9c3c4; WORD $0x00c4 // vpinsrq $0, %r12, %xmm0, %xmm0 LONG $0xf0e08341 // andl $-16, %r8d + QUAD $0xfffd1605027de3c4; WORD $0xf0ff // vpblendd $240, $-746(%rip), %ymm0, %ymm0 /* LCPI9_0(%rip) */ LONG $0xf0488d41 // leal $-16(%r8), %ecx WORD $0xcf89 // movl %ecx, %edi WORD $0xefc1; BYTE $0x04 // shrl $4, %edi @@ -4238,21 +3896,22 @@ LBB13_47: WORD $0xfe89 // movl %edi, %esi WORD $0xe683; BYTE $0x03 // andl $3, %esi WORD $0xf983; BYTE $0x30 // cmpl $48, %ecx - LONG $0x0016830f; WORD $0x0000 // jae LBB13_51, $22(%rip) - QUAD $0xfffcba15597de2c4; BYTE $0xff // vpbroadcastq $-838(%rip), %ymm2 /* LCPI13_1(%rip) */ + LONG $0x0016830f; WORD $0x0000 // jae LBB9_45, $22(%rip) + QUAD $0xfffd1415597de2c4; BYTE $0xff // vpbroadcastq $-748(%rip), %ymm2 /* LCPI9_1(%rip) */ LONG $0xda6ffdc5 // vmovdqa %ymm2, %ymm3 LONG $0xca6ffdc5 // vmovdqa %ymm2, %ymm1 - LONG $0x00007ee9; BYTE $0x00 // jmp LBB13_53, $126(%rip) + LONG $0x000088e9; BYTE $0x00 // jmp LBB9_47, $136(%rip) -LBB13_51: +LBB9_45: WORD $0xe783; BYTE $0xfc // andl $-4, %edi - QUAD $0xfffca115597de2c4; BYTE $0xff // vpbroadcastq $-863(%rip), %ymm2 /* LCPI13_1(%rip) */ - QUAD $0xfffca025597de2c4; BYTE $0xff // vpbroadcastq $-864(%rip), %ymm4 /* LCPI13_2(%rip) */ + WORD $0xdff7 // negl %edi + QUAD $0xfffcf915597de2c4; BYTE $0xff // vpbroadcastq $-775(%rip), %ymm2 /* LCPI9_1(%rip) */ + QUAD $0xfffcf825597de2c4; BYTE $0xff // vpbroadcastq $-776(%rip), %ymm4 /* LCPI9_2(%rip) */ LONG $0xda6ffdc5 // vmovdqa %ymm2, %ymm3 LONG $0xca6ffdc5 // vmovdqa %ymm2, %ymm1 + QUAD $0x9090909090909090 // .p2align 4, 0x90 - // .p2align 4, 0x90 -LBB13_52: +LBB9_46: LONG $0xecf4fdc5 // vpmuludq %ymm4, %ymm0, %ymm5 LONG $0xd073fdc5; BYTE $0x20 // vpsrlq $32, %ymm0, %ymm0 LONG $0xc4f4fdc5 // vpmuludq %ymm4, %ymm0, %ymm0 @@ -4273,16 +3932,17 @@ LBB13_52: LONG $0xccf4f5c5 // vpmuludq %ymm4, %ymm1, %ymm1 LONG $0xf173f5c5; BYTE $0x20 // vpsllq $32, %ymm1, %ymm1 LONG $0xc9d4d5c5 // vpaddq %ymm1, %ymm5, %ymm1 - WORD $0xc783; BYTE $0xfc // addl $-4, %edi - LONG $0xff9f850f; WORD $0xffff // jne LBB13_52, $-97(%rip) + WORD $0xc783; BYTE $0x04 // addl $4, %edi + LONG $0xff9f850f; WORD $0xffff // jne LBB9_46, $-97(%rip) -LBB13_53: - WORD $0xf685 // testl %esi, %esi - LONG $0x0077840f; WORD $0x0000 // je LBB13_56, $119(%rip) - QUAD $0xfffc2e25597de2c4; BYTE $0xff // vpbroadcastq $-978(%rip), %ymm4 /* LCPI13_3(%rip) */ - QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 +LBB9_47: + WORD $0xf685 // testl %esi, %esi + LONG $0x0077840f; WORD $0x0000 // je LBB9_50, $119(%rip) + WORD $0xdef7 // negl %esi + QUAD $0xfffc7c25597de2c4; BYTE $0xff // vpbroadcastq $-900(%rip), %ymm4 /* LCPI9_3(%rip) */ + QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90 -LBB13_55: +LBB9_49: LONG $0xecf4fdc5 // vpmuludq %ymm4, %ymm0, %ymm5 LONG $0xd073fdc5; BYTE $0x20 // vpsrlq $32, %ymm0, %ymm0 LONG $0xc4f4fdc5 // vpmuludq %ymm4, %ymm0, %ymm0 @@ -4303,10 +3963,10 @@ LBB13_55: LONG $0xccf4f5c5 // vpmuludq %ymm4, %ymm1, %ymm1 LONG $0xf173f5c5; BYTE $0x20 // vpsllq $32, %ymm1, %ymm1 LONG $0xc9d4d5c5 // vpaddq %ymm1, %ymm5, %ymm1 - WORD $0xceff // decl %esi - LONG $0xffa0850f; WORD $0xffff // jne LBB13_55, $-96(%rip) + WORD $0xc6ff // incl %esi + LONG $0xffa0850f; WORD $0xffff // jne LBB9_49, $-96(%rip) -LBB13_56: +LBB9_50: LONG $0xd273ddc5; BYTE $0x20 // vpsrlq $32, %ymm2, %ymm4 LONG $0xe0f4ddc5 // vpmuludq %ymm0, %ymm4, %ymm4 LONG $0xd073d5c5; BYTE $0x20 // vpsrlq $32, %ymm0, %ymm5 @@ -4340,10 +4000,10 @@ LBB13_56: LONG $0xf273e9c5; BYTE $0x20 // vpsllq $32, %xmm2, %xmm2 LONG $0xc1f4f9c5 // vpmuludq %xmm1, %xmm0, %xmm0 LONG $0xc2d4f9c5 // vpaddq %xmm2, %xmm0, %xmm0 - LONG $0xc870f9c5; BYTE $0xee // vpshufd $238, %xmm0, %xmm1 + LONG $0xc870f9c5; BYTE $0x4e // vpshufd $78, %xmm0, %xmm1 LONG $0xd073e9c5; BYTE $0x20 // vpsrlq $32, %xmm0, %xmm2 LONG $0xd1f4e9c5 // vpmuludq %xmm1, %xmm2, %xmm2 - LONG $0xd870f9c5; BYTE $0xff // vpshufd $255, %xmm0, %xmm3 + LONG $0xd873e1c5; BYTE $0x0c // vpsrldq $12, %xmm0, %xmm3 LONG $0xdbf4f9c5 // vpmuludq %xmm3, %xmm0, %xmm3 LONG $0xd2d4e1c5 // vpaddq %xmm2, %xmm3, %xmm2 LONG $0xf273e9c5; BYTE $0x20 // vpsllq $32, %xmm2, %xmm2 @@ -4351,58 +4011,65 @@ LBB13_56: LONG $0xc2d4f9c5 // vpaddq %xmm2, %xmm0, %xmm0 LONG $0x7ef9c1c4; BYTE $0xc4 // vmovq %xmm0, %r12 WORD $0x3944; BYTE $0xc2 // cmpl %r8d, %edx - LONG $0x0017840f; WORD $0x0000 // je LBB13_60, $23(%rip) + LONG $0x0017840f; WORD $0x0000 // je LBB9_54, $23(%rip) WORD $0x0145; BYTE $0xc1 // addl %r8d, %r9d -LBB13_58: +LBB9_52: WORD $0xc289 // movl %eax, %edx WORD $0x2944; BYTE $0xca // subl %r9d, %edx // .p2align 4, 0x90 -LBB13_59: +LBB9_53: WORD $0x014d; BYTE $0xe4 // addq %r12, %r12 LONG $0xa4248d4f // leaq (%r12,%r12,4), %r12 WORD $0xcaff // decl %edx - LONG $0xfff1850f; WORD $0xffff // jne LBB13_59, $-15(%rip) + LONG $0xfff1850f; WORD $0xffff // jne LBB9_53, $-15(%rip) -LBB13_60: +LBB9_54: WORD $0xc085 // testl %eax, %eax - LONG $0x004b880f; WORD $0x0000 // js LBB13_67, $75(%rip) - LONG $0x10578b41 // movl $16(%r15), %edx - WORD $0xc239 // cmpl %eax, %edx - LONG $0x003f8e0f; WORD $0x0000 // jle LBB13_67, $63(%rip) - WORD $0x8b49; BYTE $0x37 // movq (%r15), %rsi - LONG $0x060cb60f // movzbl (%rsi,%rax), %ecx - WORD $0xf980; BYTE $0x35 // cmpb $53, %cl - LONG $0x00b2850f; WORD $0x0000 // jne LBB13_69, $178(%rip) + LONG $0x0049880f; WORD $0x0000 // js LBB9_62, $73(%rip) + LONG $0x10778b41 // movl $16(%r15), %esi + WORD $0xc639 // cmpl %eax, %esi + LONG $0x003d8e0f; WORD $0x0000 // jle LBB9_62, $61(%rip) + WORD $0x8b49; BYTE $0x17 // movq (%r15), %rdx + WORD $0x0c8a; BYTE $0x02 // movb (%rdx,%rax), %cl WORD $0x788d; BYTE $0x01 // leal $1(%rax), %edi - WORD $0xd739 // cmpl %edx, %edi - LONG $0x00a7850f; WORD $0x0000 // jne LBB13_69, $167(%rip) - WORD $0x01b2 // movb $1, %dl + WORD $0xf739 // cmpl %esi, %edi + LONG $0x00c1850f; WORD $0x0000 // jne LBB9_63, $193(%rip) + WORD $0xf980; BYTE $0x35 // cmpb $53, %cl + LONG $0x00b8850f; WORD $0x0000 // jne LBB9_63, $184(%rip) LONG $0x1c7f8341; BYTE $0x00 // cmpl $0, $28(%r15) - LONG $0x0019850f; WORD $0x0000 // jne LBB13_70, $25(%rip) - WORD $0x8548; BYTE $0xc0 // testq %rax, %rax - LONG $0x000e840f; WORD $0x0000 // je LBB13_67, $14(%rip) + WORD $0x950f; BYTE $0xc1 // setne %cl + LONG $0x0017850f; WORD $0x0000 // jne LBB9_64, $23(%rip) + WORD $0xc085 // testl %eax, %eax + LONG $0x000f8e0f; WORD $0x0000 // jle LBB9_64, $15(%rip) WORD $0xc8ff // decl %eax - LONG $0x0614b60f // movzbl (%rsi,%rax), %edx - WORD $0xe280; BYTE $0x01 // andb $1, %dl - LONG $0x000002e9; BYTE $0x00 // jmp LBB13_70, $2(%rip) + WORD $0x0c8a; BYTE $0x02 // movb (%rdx,%rax), %cl + WORD $0xe180; BYTE $0x01 // andb $1, %cl + LONG $0x000002e9; BYTE $0x00 // jmp LBB9_64, $2(%rip) -LBB13_67: - WORD $0xd231 // xorl %edx, %edx +LBB9_62: + WORD $0xc931 // xorl %ecx, %ecx -LBB13_70: - WORD $0xb60f; BYTE $0xc2 // movzbl %dl, %eax +LBB9_64: + WORD $0xb60f; BYTE $0xc1 // movzbl %cl, %eax WORD $0x0149; BYTE $0xc4 // addq %rax, %r12 QUAD $0x000000000000b848; WORD $0x0020 // movabsq $9007199254740992, %rax WORD $0x3949; BYTE $0xc4 // cmpq %rax, %r12 - LONG $0x0013850f; WORD $0x0000 // jne LBB13_73, $19(%rip) + LONG $0x0025850f; WORD $0x0000 // jne LBB9_68, $37(%rip) LONG $0xfefe8141; WORD $0x0003; BYTE $0x00 // cmpl $1022, %r14d - LONG $0xfaad8f0f; WORD $0xffff // jg LBB13_2, $-1363(%rip) - WORD $0xff41; BYTE $0xc6 // incl %r14d - WORD $0x894d; BYTE $0xec // movq %r13, %r12 + LONG $0x00128e0f; WORD $0x0000 // jle LBB9_67, $18(%rip) + +LBB9_66: + WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d + QUAD $0x000000000000be49; WORD $0x7ff0 // movabsq $9218868437227405312, %r14 + LONG $0x000025e9; BYTE $0x00 // jmp LBB9_69, $37(%rip) -LBB13_73: +LBB9_67: + WORD $0xff41; BYTE $0xc6 // incl %r14d + WORD $0x894d; BYTE $0xec // movq %r13, %r12 + +LBB9_68: WORD $0x894c; BYTE $0xe0 // movq %r12, %rax WORD $0x214c; BYTE $0xe8 // andq %r13, %rax LONG $0xffc68141; WORD $0x0003; BYTE $0x00 // addl $1023, %r14d @@ -4411,7 +4078,7 @@ LBB13_73: WORD $0x8548; BYTE $0xc0 // testq %rax, %rax LONG $0xf0440f4c // cmoveq %rax, %r14 -LBB13_74: +LBB9_69: WORD $0xff49; BYTE $0xcd // decq %r13 WORD $0x214d; BYTE $0xe5 // andq %r12, %r13 WORD $0x094d; BYTE $0xf5 // orq %r14, %r13 @@ -4431,305 +4098,199 @@ LBB13_74: WORD $0xf8c5; BYTE $0x77 // vzeroupper BYTE $0xc3 // retq -LBB13_69: - WORD $0xf980; BYTE $0x35 // cmpb $53, %cl - WORD $0x9d0f; BYTE $0xc2 // setge %dl - LONG $0xffff74e9; BYTE $0xff // jmp LBB13_70, $-140(%rip) +LBB9_63: + WORD $0xf980; BYTE $0x34 // cmpb $52, %cl + WORD $0x9f0f; BYTE $0xc1 // setg %cl + LONG $0xffff62e9; BYTE $0xff // jmp LBB9_64, $-158(%rip) // .p2align 4, 0x90 _atof_native: - BYTE $0x55 // pushq %rbp - WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp - WORD $0x5741 // pushq %r15 - WORD $0x5641 // pushq %r14 - WORD $0x5541 // pushq %r13 - WORD $0x5441 // pushq %r12 - BYTE $0x53 // pushq %rbx - LONG $0x28ec8348 // subq $40, %rsp - QUAD $0x00000000d045c748 // movq $0, $-48(%rbp) - LONG $0xb0558948 // movq %rdx, $-80(%rbp) - LONG $0xb84d8948 // movq %rcx, $-72(%rbp) - WORD $0x8548; BYTE $0xc9 // testq %rcx, %rcx - LONG $0x0197840f; WORD $0x0000 // je LBB14_18, $407(%rip) - LONG $0x10f98348 // cmpq $16, %rcx - LONG $0x0008830f; WORD $0x0000 // jae LBB14_3, $8(%rip) - WORD $0x3145; BYTE $0xd2 // xorl %r10d, %r10d - LONG $0x000174e9; BYTE $0x00 // jmp LBB14_17, $372(%rip) - -LBB14_3: - LONG $0x80f98148; WORD $0x0000; BYTE $0x00 // cmpq $128, %rcx - LONG $0x0008830f; WORD $0x0000 // jae LBB14_5, $8(%rip) - WORD $0x3145; BYTE $0xd2 // xorl %r10d, %r10d - LONG $0x000129e9; BYTE $0x00 // jmp LBB14_14, $297(%rip) - -LBB14_5: - WORD $0x8949; BYTE $0xca // movq %rcx, %r10 - LONG $0x80e28349 // andq $-128, %r10 - LONG $0x80428d49 // leaq $-128(%r10), %rax - WORD $0x8949; BYTE $0xc1 // movq %rax, %r9 - LONG $0x07e9c149 // shrq $7, %r9 - WORD $0xff49; BYTE $0xc1 // incq %r9 - WORD $0x8945; BYTE $0xc8 // movl %r9d, %r8d - LONG $0x03e08341 // andl $3, %r8d - LONG $0x01803d48; WORD $0x0000 // cmpq $384, %rax - LONG $0x0007830f; WORD $0x0000 // jae LBB14_7, $7(%rip) - WORD $0xdb31 // xorl %ebx, %ebx - LONG $0x0000a4e9; BYTE $0x00 // jmp LBB14_9, $164(%rip) - -LBB14_7: - LONG $0xfce18349 // andq $-4, %r9 - WORD $0xdb31 // xorl %ebx, %ebx - LONG $0xc057f8c5 // vxorps %xmm0, %xmm0, %xmm0 - LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 - -LBB14_8: - LONG $0x0411fcc5; BYTE $0x1a // vmovups %ymm0, (%rdx,%rbx) - LONG $0x4411fcc5; WORD $0x201a // vmovups %ymm0, $32(%rdx,%rbx) - LONG $0x4411fcc5; WORD $0x401a // vmovups %ymm0, $64(%rdx,%rbx) - LONG $0x4411fcc5; WORD $0x601a // vmovups %ymm0, $96(%rdx,%rbx) - QUAD $0x0000801a8411fcc5; BYTE $0x00 // vmovups %ymm0, $128(%rdx,%rbx) - QUAD $0x0000a01a8411fcc5; BYTE $0x00 // vmovups %ymm0, $160(%rdx,%rbx) - QUAD $0x0000c01a8411fcc5; BYTE $0x00 // vmovups %ymm0, $192(%rdx,%rbx) - QUAD $0x0000e01a8411fcc5; BYTE $0x00 // vmovups %ymm0, $224(%rdx,%rbx) - QUAD $0x0001001a8411fcc5; BYTE $0x00 // vmovups %ymm0, $256(%rdx,%rbx) - QUAD $0x0001201a8411fcc5; BYTE $0x00 // vmovups %ymm0, $288(%rdx,%rbx) - QUAD $0x0001401a8411fcc5; BYTE $0x00 // vmovups %ymm0, $320(%rdx,%rbx) - QUAD $0x0001601a8411fcc5; BYTE $0x00 // vmovups %ymm0, $352(%rdx,%rbx) - QUAD $0x0001801a8411fcc5; BYTE $0x00 // vmovups %ymm0, $384(%rdx,%rbx) - QUAD $0x0001a01a8411fcc5; BYTE $0x00 // vmovups %ymm0, $416(%rdx,%rbx) - QUAD $0x0001c01a8411fcc5; BYTE $0x00 // vmovups %ymm0, $448(%rdx,%rbx) - QUAD $0x0001e01a8411fcc5; BYTE $0x00 // vmovups %ymm0, $480(%rdx,%rbx) - LONG $0x00c38148; WORD $0x0002; BYTE $0x00 // addq $512, %rbx - LONG $0xfcc18349 // addq $-4, %r9 - LONG $0xff6c850f; WORD $0xffff // jne LBB14_8, $-148(%rip) - -LBB14_9: - WORD $0x854d; BYTE $0xc0 // testq %r8, %r8 - LONG $0x003b840f; WORD $0x0000 // je LBB14_12, $59(%rip) - LONG $0x130c8d4c // leaq (%rbx,%rdx), %r9 - LONG $0x60c18349 // addq $96, %r9 - LONG $0x07e0c149 // shlq $7, %r8 - WORD $0xdb31 // xorl %ebx, %ebx - LONG $0xc057f8c5 // vxorps %xmm0, %xmm0, %xmm0 - BYTE $0x90 // .p2align 4, 0x90 - -LBB14_11: - LONG $0x117cc1c4; WORD $0x1944; BYTE $0xa0 // vmovups %ymm0, $-96(%r9,%rbx) - LONG $0x117cc1c4; WORD $0x1944; BYTE $0xc0 // vmovups %ymm0, $-64(%r9,%rbx) - LONG $0x117cc1c4; WORD $0x1944; BYTE $0xe0 // vmovups %ymm0, $-32(%r9,%rbx) - LONG $0x117cc1c4; WORD $0x1904 // vmovups %ymm0, (%r9,%rbx) - LONG $0x80eb8348 // subq $-128, %rbx - WORD $0x3949; BYTE $0xd8 // cmpq %rbx, %r8 - LONG $0xffd8850f; WORD $0xffff // jne LBB14_11, $-40(%rip) - -LBB14_12: - WORD $0x3949; BYTE $0xca // cmpq %rcx, %r10 - LONG $0x0050840f; WORD $0x0000 // je LBB14_18, $80(%rip) - WORD $0xc1f6; BYTE $0x70 // testb $112, %cl - LONG $0x0036840f; WORD $0x0000 // je LBB14_17, $54(%rip) - -LBB14_14: - WORD $0x894c; BYTE $0xd0 // movq %r10, %rax - WORD $0x8949; BYTE $0xca // movq %rcx, %r10 - LONG $0xf0e28349 // andq $-16, %r10 - LONG $0xc057f8c5 // vxorps %xmm0, %xmm0, %xmm0 - QUAD $0x9090909090909090 // .p2align 4, 0x90 - -LBB14_15: - LONG $0x0411f8c5; BYTE $0x02 // vmovups %xmm0, (%rdx,%rax) - LONG $0x10c08348 // addq $16, %rax - WORD $0x3949; BYTE $0xc2 // cmpq %rax, %r10 - LONG $0xffee850f; WORD $0xffff // jne LBB14_15, $-18(%rip) - WORD $0x3949; BYTE $0xca // cmpq %rcx, %r10 - LONG $0x0016840f; WORD $0x0000 // je LBB14_18, $22(%rip) - LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + LONG $0x30ec8348 // subq $48, %rsp + QUAD $0x00000000d845c748 // movq $0, $-40(%rbp) + LONG $0xe0558948 // movq %rdx, $-32(%rbp) + LONG $0xe84d8948 // movq %rcx, $-24(%rbp) + WORD $0x8548; BYTE $0xc9 // testq %rcx, %rcx + LONG $0x0044840f; WORD $0x0000 // je LBB10_5, $68(%rip) + WORD $0x02c6; BYTE $0x00 // movb $0, (%rdx) + LONG $0x01f98348 // cmpq $1, %rcx + LONG $0x0037840f; WORD $0x0000 // je LBB10_5, $55(%rip) + LONG $0x000142c6 // movb $0, $1(%rdx) + LONG $0xe87d8348; BYTE $0x03 // cmpq $3, $-24(%rbp) + LONG $0x0028820f; WORD $0x0000 // jb LBB10_5, $40(%rip) + LONG $0x000002b8; BYTE $0x00 // movl $2, %eax + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 -LBB14_17: - LONG $0x1204c642; BYTE $0x00 // movb $0, (%rdx,%r10) - WORD $0xff49; BYTE $0xc2 // incq %r10 - WORD $0x394c; BYTE $0xd1 // cmpq %r10, %rcx - LONG $0xffef850f; WORD $0xffff // jne LBB14_17, $-17(%rip) +LBB10_4: + LONG $0xe04d8b48 // movq $-32(%rbp), %rcx + LONG $0x000104c6 // movb $0, (%rcx,%rax) + WORD $0xff48; BYTE $0xc0 // incq %rax + LONG $0xe8453948 // cmpq %rax, $-24(%rbp) + LONG $0xffeb870f; WORD $0xffff // ja LBB10_4, $-21(%rip) -LBB14_18: - LONG $0x00c045c7; WORD $0x0000; BYTE $0x00 // movl $0, $-64(%rbp) - QUAD $0x00000000c845c748 // movq $0, $-56(%rbp) - WORD $0x3145; BYTE $0xc0 // xorl %r8d, %r8d +LBB10_5: + LONG $0xc057f8c5 // vxorps %xmm0, %xmm0, %xmm0 + LONG $0x4511f8c5; BYTE $0xf0 // vmovups %xmm0, $-16(%rbp) WORD $0x3f80; BYTE $0x2d // cmpb $45, (%rdi) - LONG $0x001b850f; WORD $0x0000 // jne LBB14_19, $27(%rip) - LONG $0x01c845c7; WORD $0x0000; BYTE $0x00 // movl $1, $-56(%rbp) - LONG $0x0001bd41; WORD $0x0000 // movl $1, %r13d - WORD $0x3949; BYTE $0xf5 // cmpq %rsi, %r13 - LONG $0x00118c0f; WORD $0x0000 // jl LBB14_22, $17(%rip) - LONG $0x0001b5e9; BYTE $0x00 // jmp LBB14_54, $437(%rip) - -LBB14_19: - WORD $0x3145; BYTE $0xed // xorl %r13d, %r13d - WORD $0x3949; BYTE $0xf5 // cmpq %rsi, %r13 - LONG $0x01a98d0f; WORD $0x0000 // jge LBB14_54, $425(%rip) - -LBB14_22: - WORD $0xb741; BYTE $0x01 // movb $1, %r15b - WORD $0x3145; BYTE $0xc0 // xorl %r8d, %r8d - WORD $0x3145; BYTE $0xc9 // xorl %r9d, %r9d - WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d - WORD $0x3145; BYTE $0xdb // xorl %r11d, %r11d - WORD $0xdb31 // xorl %ebx, %ebx - LONG $0x000027e9; BYTE $0x00 // jmp LBB14_23, $39(%rip) - LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + LONG $0x0021850f; WORD $0x0000 // jne LBB10_8, $33(%rip) + LONG $0x01f845c7; WORD $0x0000; BYTE $0x00 // movl $1, $-8(%rbp) + LONG $0x000001b8; BYTE $0x00 // movl $1, %eax + WORD $0x3948; BYTE $0xf0 // cmpq %rsi, %rax + LONG $0x00178c0f; WORD $0x0000 // jl LBB10_9, $23(%rip) -LBB14_33: - LONG $0x000001bb; BYTE $0x00 // movl $1, %ebx - WORD $0x8945; BYTE $0xdc // movl %r11d, %r12d - WORD $0x2e3c // cmpb $46, %al - LONG $0x0095850f; WORD $0x0000 // jne LBB14_36, $149(%rip) +LBB10_7: + LONG $0x00f445c7; WORD $0x0000; BYTE $0x00 // movl $0, $-12(%rbp) + LONG $0x0001a1e9; BYTE $0x00 // jmp LBB10_39, $417(%rip) -LBB14_34: - WORD $0xff49; BYTE $0xc5 // incq %r13 - WORD $0x3949; BYTE $0xf5 // cmpq %rsi, %r13 - LONG $0xc79c0f41 // setl %r15b - LONG $0x007c840f; WORD $0x0000 // je LBB14_35, $124(%rip) - -LBB14_23: - WORD $0x8941; BYTE $0xda // movl %ebx, %r10d - WORD $0x8945; BYTE $0xe6 // movl %r12d, %r14d - LONG $0x04b60f42; BYTE $0x2f // movzbl (%rdi,%r13), %eax - WORD $0x588d; BYTE $0xd0 // leal $-48(%rax), %ebx - WORD $0xfb80; BYTE $0x09 // cmpb $9, %bl - LONG $0xffc9870f; WORD $0xffff // ja LBB14_33, $-55(%rip) - WORD $0x303c // cmpb $48, %al - LONG $0x0021850f; WORD $0x0000 // jne LBB14_29, $33(%rip) - WORD $0x8545; BYTE $0xdb // testl %r11d, %r11d - LONG $0x0043840f; WORD $0x0000 // je LBB14_26, $67(%rip) - WORD $0x6349; BYTE $0xd8 // movslq %r8d, %rbx - WORD $0x3948; BYTE $0xcb // cmpq %rcx, %rbx - LONG $0x0018820f; WORD $0x0000 // jb LBB14_32, $24(%rip) - LONG $0x000019e9; BYTE $0x00 // jmp LBB14_28, $25(%rip) - LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 +LBB10_8: + WORD $0xc031 // xorl %eax, %eax + WORD $0x3948; BYTE $0xf0 // cmpq %rsi, %rax + LONG $0xffe98d0f; WORD $0xffff // jge LBB10_7, $-23(%rip) -LBB14_29: - WORD $0x6349; BYTE $0xdb // movslq %r11d, %rbx - WORD $0x3948; BYTE $0xcb // cmpq %rcx, %rbx - LONG $0x0014830f; WORD $0x0000 // jae LBB14_30, $20(%rip) +LBB10_9: + WORD $0xb341; BYTE $0x01 // movb $1, %r11b + WORD $0x3145; BYTE $0xc9 // xorl %r9d, %r9d + WORD $0x3145; BYTE $0xd2 // xorl %r10d, %r10d + WORD $0x3145; BYTE $0xc0 // xorl %r8d, %r8d + LONG $0x00001fe9; BYTE $0x00 // jmp LBB10_13, $31(%rip) -LBB14_32: - WORD $0x0488; BYTE $0x1a // movb %al, (%rdx,%rbx) - WORD $0xff41; BYTE $0xc0 // incl %r8d +LBB10_21: + LONG $0x01fc45c7; WORD $0x0000; BYTE $0x00 // movl $1, $-4(%rbp) + LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 -LBB14_28: - WORD $0x8945; BYTE $0xf4 // movl %r14d, %r12d - WORD $0x8945; BYTE $0xc3 // movl %r8d, %r11d - WORD $0x8944; BYTE $0xd3 // movl %r10d, %ebx - LONG $0xffff90e9; BYTE $0xff // jmp LBB14_34, $-112(%rip) +LBB10_12: + WORD $0xff48; BYTE $0xc0 // incq %rax + WORD $0x3948; BYTE $0xf0 // cmpq %rsi, %rax + LONG $0xc39c0f41 // setl %r11b + WORD $0x3948; BYTE $0xc6 // cmpq %rax, %rsi + LONG $0x0090840f; WORD $0x0000 // je LBB10_23, $144(%rip) + +LBB10_13: + LONG $0x070cb60f // movzbl (%rdi,%rax), %ecx + WORD $0x518d; BYTE $0xd0 // leal $-48(%rcx), %edx + WORD $0xfa80; BYTE $0x09 // cmpb $9, %dl + LONG $0x002d870f; WORD $0x0000 // ja LBB10_18, $45(%rip) + WORD $0xf980; BYTE $0x30 // cmpb $48, %cl + LONG $0x0044850f; WORD $0x0000 // jne LBB10_20, $68(%rip) + WORD $0x8545; BYTE $0xd2 // testl %r10d, %r10d + LONG $0x0063840f; WORD $0x0000 // je LBB10_22, $99(%rip) + WORD $0x634d; BYTE $0xd9 // movslq %r9d, %r11 + LONG $0xe85d394c // cmpq %r11, $-24(%rbp) + LONG $0x003b870f; WORD $0x0000 // ja LBB10_10, $59(%rip) + LONG $0x000049e9; BYTE $0x00 // jmp LBB10_11, $73(%rip) + QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90 -LBB14_30: - LONG $0x0001b941; WORD $0x0000 // movl $1, %r9d - LONG $0x000006e9; BYTE $0x00 // jmp LBB14_31, $6(%rip) +LBB10_18: + WORD $0xf980; BYTE $0x2e // cmpb $46, %cl + LONG $0x009b850f; WORD $0x0000 // jne LBB10_30, $155(%rip) + LONG $0xf4558944 // movl %r10d, $-12(%rbp) + LONG $0x0001b841; WORD $0x0000 // movl $1, %r8d + LONG $0xffff98e9; BYTE $0xff // jmp LBB10_12, $-104(%rip) + QUAD $0x9090909090909090 // .p2align 4, 0x90 -LBB14_26: - WORD $0xff41; BYTE $0xce // decl %r14d - WORD $0x3145; BYTE $0xdb // xorl %r11d, %r11d +LBB10_20: + WORD $0x634d; BYTE $0xda // movslq %r10d, %r11 + LONG $0xe85d394c // cmpq %r11, $-24(%rbp) + LONG $0xff77860f; WORD $0xffff // jbe LBB10_21, $-137(%rip) -LBB14_31: - WORD $0x8945; BYTE $0xf4 // movl %r14d, %r12d - WORD $0x8944; BYTE $0xd3 // movl %r10d, %ebx - LONG $0xffff74e9; BYTE $0xff // jmp LBB14_34, $-140(%rip) +LBB10_10: + LONG $0xe0558b48 // movq $-32(%rbp), %rdx + LONG $0x1a0c8842 // movb %cl, (%rdx,%r11) + LONG $0xf04d8b44 // movl $-16(%rbp), %r9d + WORD $0xff41; BYTE $0xc1 // incl %r9d + LONG $0xf04d8944 // movl %r9d, $-16(%rbp) -LBB14_35: - WORD $0x8945; BYTE $0xe6 // movl %r12d, %r14d - WORD $0x8949; BYTE $0xf5 // movq %rsi, %r13 - WORD $0x8941; BYTE $0xda // movl %ebx, %r10d - -LBB14_36: - LONG $0xc4758944 // movl %r14d, $-60(%rbp) - LONG $0xcc4d8944 // movl %r9d, $-52(%rbp) - LONG $0xc0458944 // movl %r8d, $-64(%rbp) - WORD $0x8545; BYTE $0xd2 // testl %r10d, %r10d - LONG $0x0012840f; WORD $0x0000 // je LBB14_37, $18(%rip) - WORD $0x8945; BYTE $0xf0 // movl %r14d, %r8d - LONG $0x01c7f641 // testb $1, %r15b - LONG $0x0013850f; WORD $0x0000 // jne LBB14_40, $19(%rip) - LONG $0x0000c4e9; BYTE $0x00 // jmp LBB14_55, $196(%rip) +LBB10_11: + WORD $0x8945; BYTE $0xca // movl %r9d, %r10d + LONG $0xffff68e9; BYTE $0xff // jmp LBB10_12, $-152(%rip) -LBB14_37: - LONG $0xc4458944 // movl %r8d, $-60(%rbp) - LONG $0x01c7f641 // testb $1, %r15b - LONG $0x00b6840f; WORD $0x0000 // je LBB14_55, $182(%rip) +LBB10_22: + WORD $0x4dff; BYTE $0xf4 // decl $-12(%rbp) + WORD $0x3145; BYTE $0xd2 // xorl %r10d, %r10d + LONG $0xffff5de9; BYTE $0xff // jmp LBB10_12, $-163(%rip) -LBB14_40: - WORD $0x8944; BYTE $0xe8 // movl %r13d, %eax - LONG $0x070cb60f // movzbl (%rdi,%rax), %ecx - WORD $0xc983; BYTE $0x20 // orl $32, %ecx - WORD $0xf983; BYTE $0x65 // cmpl $101, %ecx - LONG $0x00a3850f; WORD $0x0000 // jne LBB14_55, $163(%rip) - LONG $0x0754b60f; BYTE $0x01 // movzbl $1(%rdi,%rax), %edx - WORD $0xfa83; BYTE $0x2d // cmpl $45, %edx - LONG $0x0017840f; WORD $0x0000 // je LBB14_45, $23(%rip) - LONG $0x000001b9; BYTE $0x00 // movl $1, %ecx - WORD $0xfa83; BYTE $0x2b // cmpl $43, %edx - LONG $0x0028850f; WORD $0x0000 // jne LBB14_43, $40(%rip) - LONG $0x02c58341 // addl $2, %r13d - LONG $0x000009e9; BYTE $0x00 // jmp LBB14_46, $9(%rip) - -LBB14_45: - LONG $0x02c58341 // addl $2, %r13d - LONG $0xffffffb9; BYTE $0xff // movl $-1, %ecx +LBB10_23: + WORD $0xf189 // movl %esi, %ecx + WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax + WORD $0x8545; BYTE $0xc0 // testl %r8d, %r8d + LONG $0x0004850f; WORD $0x0000 // jne LBB10_25, $4(%rip) + +LBB10_24: + LONG $0xf44d8944 // movl %r9d, $-12(%rbp) + +LBB10_25: + LONG $0x01c3f641 // testb $1, %r11b + LONG $0x00ba840f; WORD $0x0000 // je LBB10_39, $186(%rip) + WORD $0x0c8a; BYTE $0x0f // movb (%rdi,%rcx), %cl + WORD $0xc980; BYTE $0x20 // orb $32, %cl + WORD $0xf980; BYTE $0x65 // cmpb $101, %cl + LONG $0x00ab850f; WORD $0x0000 // jne LBB10_39, $171(%rip) + WORD $0xc289 // movl %eax, %edx + LONG $0x01174c8a // movb $1(%rdi,%rdx), %cl + WORD $0xf980; BYTE $0x2d // cmpb $45, %cl + LONG $0x0028840f; WORD $0x0000 // je LBB10_31, $40(%rip) + LONG $0x0001b841; WORD $0x0000 // movl $1, %r8d + WORD $0xf980; BYTE $0x2b // cmpb $43, %cl + LONG $0x0038850f; WORD $0x0000 // jne LBB10_33, $56(%rip) + WORD $0xc083; BYTE $0x02 // addl $2, %eax + LONG $0x00001ae9; BYTE $0x00 // jmp LBB10_32, $26(%rip) + +LBB10_30: + WORD $0x8948; BYTE $0xc1 // movq %rax, %rcx + WORD $0x8545; BYTE $0xc0 // testl %r8d, %r8d + LONG $0xffb5850f; WORD $0xffff // jne LBB10_25, $-75(%rip) + LONG $0xfffface9; BYTE $0xff // jmp LBB10_24, $-84(%rip) -LBB14_46: - WORD $0x8944; BYTE $0xe8 // movl %r13d, %eax - WORD $0x6348; BYTE $0xd0 // movslq %eax, %rdx - WORD $0xc031 // xorl %eax, %eax - WORD $0x3948; BYTE $0xf2 // cmpq %rsi, %rdx - LONG $0x00168c0f; WORD $0x0000 // jl LBB14_48, $22(%rip) - LONG $0x000055e9; BYTE $0x00 // jmp LBB14_53, $85(%rip) +LBB10_31: + WORD $0xc083; BYTE $0x02 // addl $2, %eax + LONG $0xffffb841; WORD $0xffff // movl $-1, %r8d -LBB14_43: - WORD $0xff48; BYTE $0xc0 // incq %rax - WORD $0x6348; BYTE $0xd0 // movslq %eax, %rdx - WORD $0xc031 // xorl %eax, %eax +LBB10_32: + WORD $0xc289 // movl %eax, %edx + WORD $0x6348; BYTE $0xd2 // movslq %edx, %rdx + WORD $0x3145; BYTE $0xc9 // xorl %r9d, %r9d WORD $0x3948; BYTE $0xf2 // cmpq %rsi, %rdx - LONG $0x00448d0f; WORD $0x0000 // jge LBB14_53, $68(%rip) + LONG $0x00178c0f; WORD $0x0000 // jl LBB10_34, $23(%rip) + LONG $0x00004de9; BYTE $0x00 // jmp LBB10_38, $77(%rip) -LBB14_48: - WORD $0xc031 // xorl %eax, %eax - QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90 - -LBB14_49: - LONG $0x171cbe0f // movsbl (%rdi,%rdx), %ebx - WORD $0xfb83; BYTE $0x30 // cmpl $48, %ebx - LONG $0x00298c0f; WORD $0x0000 // jl LBB14_53, $41(%rip) - WORD $0xfb80; BYTE $0x39 // cmpb $57, %bl - LONG $0x0020870f; WORD $0x0000 // ja LBB14_53, $32(%rip) - LONG $0x00270f3d; BYTE $0x00 // cmpl $9999, %eax - LONG $0x00158f0f; WORD $0x0000 // jg LBB14_53, $21(%rip) - WORD $0x048d; BYTE $0x80 // leal (%rax,%rax,4), %eax - WORD $0x048d; BYTE $0x43 // leal (%rbx,%rax,2), %eax - WORD $0xc083; BYTE $0xd0 // addl $-48, %eax +LBB10_33: WORD $0xff48; BYTE $0xc2 // incq %rdx - WORD $0x3948; BYTE $0xd6 // cmpq %rdx, %rsi - LONG $0xffca850f; WORD $0xffff // jne LBB14_49, $-54(%rip) - -LBB14_53: - WORD $0xaf0f; BYTE $0xc1 // imull %ecx, %eax - WORD $0x0141; BYTE $0xc0 // addl %eax, %r8d + WORD $0x6348; BYTE $0xd2 // movslq %edx, %rdx + WORD $0x3145; BYTE $0xc9 // xorl %r9d, %r9d + WORD $0x3948; BYTE $0xf2 // cmpq %rsi, %rdx + LONG $0x003b8d0f; WORD $0x0000 // jge LBB10_38, $59(%rip) -LBB14_54: - LONG $0xc4458944 // movl %r8d, $-60(%rbp) +LBB10_34: + WORD $0x3145; BYTE $0xc9 // xorl %r9d, %r9d + LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 -LBB14_55: - LONG $0xb07d8d48 // leaq $-80(%rbp), %rdi - LONG $0xd0758d48 // leaq $-48(%rbp), %rsi - WORD $0xf8c5; BYTE $0x77 // vzeroupper - LONG $0xfff650e8; BYTE $0xff // callq _decimal_to_f64, $-2480(%rip) - LONG $0x4510fbc5; BYTE $0xd0 // vmovsd $-48(%rbp), %xmm0 - LONG $0x28c48348 // addq $40, %rsp - BYTE $0x5b // popq %rbx - WORD $0x5c41 // popq %r12 - WORD $0x5d41 // popq %r13 - WORD $0x5e41 // popq %r14 - WORD $0x5f41 // popq %r15 - BYTE $0x5d // popq %rbp - BYTE $0xc3 // retq - QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90 +LBB10_35: + LONG $0x0ff98141; WORD $0x0027; BYTE $0x00 // cmpl $9999, %r9d + LONG $0x00248f0f; WORD $0x0000 // jg LBB10_38, $36(%rip) + LONG $0x170cb60f // movzbl (%rdi,%rdx), %ecx + WORD $0x418d; BYTE $0xd0 // leal $-48(%rcx), %eax + WORD $0x093c // cmpb $9, %al + LONG $0x0015870f; WORD $0x0000 // ja LBB10_38, $21(%rip) + LONG $0x89048d43 // leal (%r9,%r9,4), %eax + LONG $0x414c8d44; BYTE $0xd0 // leal $-48(%rcx,%rax,2), %r9d + WORD $0xff48; BYTE $0xc2 // incq %rdx + WORD $0x3948; BYTE $0xd6 // cmpq %rdx, %rsi + LONG $0xffcf850f; WORD $0xffff // jne LBB10_35, $-49(%rip) + +LBB10_38: + LONG $0xc8af0f45 // imull %r8d, %r9d + LONG $0xf44d0144 // addl %r9d, $-12(%rbp) + +LBB10_39: + LONG $0xe07d8d48 // leaq $-32(%rbp), %rdi + LONG $0xd8758d48 // leaq $-40(%rbp), %rsi + LONG $0xfff80ae8; BYTE $0xff // callq _decimal_to_f64, $-2038(%rip) + LONG $0x4510fbc5; BYTE $0xd8 // vmovsd $-40(%rbp), %xmm0 + LONG $0x30c48348 // addq $48, %rsp + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 _value: BYTE $0x55 // pushq %rbp @@ -4740,288 +4301,296 @@ _value: WORD $0x5441 // pushq %r12 BYTE $0x53 // pushq %rbx LONG $0x28ec8348 // subq $40, %rsp - WORD $0x894d; BYTE $0xc7 // movq %r8, %r15 + WORD $0x894d; BYTE $0xc4 // movq %r8, %r12 WORD $0x8949; BYTE $0xce // movq %rcx, %r14 WORD $0x8948; BYTE $0xf3 // movq %rsi, %rbx - WORD $0x8949; BYTE $0xfc // movq %rdi, %r12 + WORD $0x8949; BYTE $0xff // movq %rdi, %r15 LONG $0xd0558948 // movq %rdx, $-48(%rbp) LONG $0xb07d8948 // movq %rdi, $-80(%rbp) LONG $0xb8758948 // movq %rsi, $-72(%rbp) - LONG $0xb07d8d48 // leaq $-80(%rbp), %rdi - LONG $0xd0758d48 // leaq $-48(%rbp), %rsi - LONG $0x00067ae8; BYTE $0x00 // callq _advance_ns, $1658(%rip) + LONG $0xd0558d48 // leaq $-48(%rbp), %rdx + LONG $0x0005dee8; BYTE $0x00 // callq _advance_ns, $1502(%rip) WORD $0xbe0f; BYTE $0xc0 // movsbl %al, %eax WORD $0xf883; BYTE $0x7d // cmpl $125, %eax - LONG $0x00bc870f; WORD $0x0000 // ja LBB15_11, $188(%rip) - LONG $0x9f0d8d48; WORD $0x0003; BYTE $0x00 // leaq $927(%rip), %rcx /* LJTI15_0(%rip) */ + LONG $0x00c3870f; WORD $0x0000 // ja LBB11_11, $195(%rip) + LONG $0xa70d8d48; WORD $0x0003; BYTE $0x00 // leaq $935(%rip), %rcx /* LJTI11_0(%rip) */ LONG $0x81046348 // movslq (%rcx,%rax,4), %rax WORD $0x0148; BYTE $0xc8 // addq %rcx, %rax JMP AX -LBB15_2: +LBB11_2: LONG $0xc875894c // movq %r14, $-56(%rbp) LONG $0xd0758b4c // movq $-48(%rbp), %r14 LONG $0xff6e8d4d // leaq $-1(%r14), %r13 LONG $0xd06d894c // movq %r13, $-48(%rbp) - LONG $0x02c7f641 // testb $2, %r15b - LONG $0x001a850f; WORD $0x0000 // jne LBB15_4, $26(%rip) + LONG $0x02c4f641 // testb $2, %r12b + LONG $0x001a850f; WORD $0x0000 // jne LBB11_4, $26(%rip) LONG $0xb07d8d48 // leaq $-80(%rbp), %rdi LONG $0xd0758d48 // leaq $-48(%rbp), %rsi LONG $0xc8558b48 // movq $-56(%rbp), %rdx - LONG $0x000e53e8; BYTE $0x00 // callq _vnumber, $3667(%rip) - LONG $0xd07d8b4c // movq $-48(%rbp), %r15 - LONG $0x00034de9; BYTE $0x00 // jmp LBB15_58, $845(%rip) + LONG $0x000c87e8; BYTE $0x00 // callq _vnumber, $3207(%rip) + LONG $0xd05d8b48 // movq $-48(%rbp), %rbx + LONG $0x000355e9; BYTE $0x00 // jmp LBB11_58, $853(%rip) -LBB15_4: +LBB11_4: WORD $0xc031 // xorl %eax, %eax - LONG $0x2c3c8043; BYTE $0x2d // cmpb $45, (%r12,%r13) - LONG $0x2c3c8d4f // leaq (%r12,%r13), %r15 + LONG $0x2f3c8043; BYTE $0x2d // cmpb $45, (%r15,%r13) + LONG $0x2f248d4f // leaq (%r15,%r13), %r12 WORD $0x940f; BYTE $0xc0 // sete %al - WORD $0x0149; BYTE $0xc7 // addq %rax, %r15 + WORD $0x0149; BYTE $0xc4 // addq %rax, %r12 WORD $0x2948; BYTE $0xc3 // subq %rax, %rbx - LONG $0x030c840f; WORD $0x0000 // je LBB15_53, $780(%rip) + LONG $0x030a840f; WORD $0x0000 // je LBB11_53, $778(%rip) WORD $0x3949; BYTE $0xdd // cmpq %rbx, %r13 - LONG $0x000e830f; WORD $0x0000 // jae LBB15_7, $14(%rip) - LONG $0x07b60f41 // movzbl (%r15), %eax - WORD $0xc604 // addb $-58, %al - WORD $0xf63c // cmpb $-10, %al - LONG $0x0307820f; WORD $0x0000 // jb LBB15_55, $775(%rip) + LONG $0x000e830f; WORD $0x0000 // jae LBB11_7, $14(%rip) + LONG $0x24048a41 // movb (%r12), %al + WORD $0xd004 // addb $-48, %al + WORD $0x0a3c // cmpb $10, %al + LONG $0x030c830f; WORD $0x0000 // jae LBB11_55, $780(%rip) -LBB15_7: - WORD $0x894c; BYTE $0xff // movq %r15, %rdi +LBB11_7: + WORD $0x894c; BYTE $0xe7 // movq %r12, %rdi WORD $0x8948; BYTE $0xde // movq %rbx, %rsi - LONG $0x0020dee8; BYTE $0x00 // callq _do_skip_number, $8414(%rip) + LONG $0x001fa2e8; BYTE $0x00 // callq _do_skip_number, $8098(%rip) WORD $0x8548; BYTE $0xc0 // testq %rax, %rax - LONG $0x02ed880f; WORD $0x0000 // js LBB15_54, $749(%rip) - WORD $0x0149; BYTE $0xc7 // addq %rax, %r15 - WORD $0x294d; BYTE $0xe7 // subq %r12, %r15 + LONG $0x02f2880f; WORD $0x0000 // js LBB11_54, $754(%rip) + WORD $0x0149; BYTE $0xc4 // addq %rax, %r12 + WORD $0x894c; BYTE $0xe3 // movq %r12, %rbx + WORD $0x294c; BYTE $0xfb // subq %r15, %rbx + LONG $0xd05d8948 // movq %rbx, $-48(%rbp) WORD $0x854d; BYTE $0xf6 // testq %r14, %r14 - LONG $0x02f28e0f; WORD $0x0000 // jle LBB15_57, $754(%rip) + LONG $0x02f38e0f; WORD $0x0000 // jle LBB11_57, $755(%rip) LONG $0xc8458b48 // movq $-56(%rbp), %rax LONG $0x0800c748; WORD $0x0000; BYTE $0x00 // movq $8, (%rax) LONG $0x1868894c // movq %r13, $24(%rax) - LONG $0x0002e5e9; BYTE $0x00 // jmp LBB15_58, $741(%rip) + LONG $0x0002e6e9; BYTE $0x00 // jmp LBB11_58, $742(%rip) -LBB15_10: +LBB11_10: LONG $0x0106c749; WORD $0x0000; BYTE $0x00 // movq $1, (%r14) - LONG $0xd07d8b4c // movq $-48(%rbp), %r15 - LONG $0x0002d5e9; BYTE $0x00 // jmp LBB15_58, $725(%rip) + LONG $0xd05d8b48 // movq $-48(%rbp), %rbx + LONG $0x0002d6e9; BYTE $0x00 // jmp LBB11_58, $726(%rip) -LBB15_11: +LBB11_11: LONG $0xfe06c749; WORD $0xffff; BYTE $0xff // movq $-2, (%r14) - LONG $0xd07d8b4c // movq $-48(%rbp), %r15 - WORD $0xff49; BYTE $0xcf // decq %r15 - LONG $0x0002c2e9; BYTE $0x00 // jmp LBB15_58, $706(%rip) + LONG $0xd05d8b48 // movq $-48(%rbp), %rbx + WORD $0xff48; BYTE $0xcb // decq %rbx + LONG $0x0002c3e9; BYTE $0x00 // jmp LBB11_58, $707(%rip) -LBB15_12: +LBB11_12: QUAD $0xffffffffc045c748 // movq $-1, $-64(%rbp) - LONG $0xd0658b4c // movq $-48(%rbp), %r12 + LONG $0xd07d8b4c // movq $-48(%rbp), %r15 LONG $0xb07d8d48 // leaq $-80(%rbp), %rdi LONG $0xc0558d48 // leaq $-64(%rbp), %rdx - WORD $0x894c; BYTE $0xe6 // movq %r12, %rsi - WORD $0x894c; BYTE $0xf9 // movq %r15, %rcx - LONG $0x000980e8; BYTE $0x00 // callq _advance_string, $2432(%rip) - WORD $0x8949; BYTE $0xc7 // movq %rax, %r15 + WORD $0x894c; BYTE $0xfe // movq %r15, %rsi + WORD $0x894c; BYTE $0xe1 // movq %r12, %rcx + LONG $0x00077de8; BYTE $0x00 // callq _advance_string, $1917(%rip) WORD $0x8548; BYTE $0xc0 // testq %rax, %rax - LONG $0x0174880f; WORD $0x0000 // js LBB15_32, $372(%rip) - LONG $0xd07d894c // movq %r15, $-48(%rbp) - LONG $0x1066894d // movq %r12, $16(%r14) - LONG $0x0706c749; WORD $0x0000; BYTE $0x00 // movq $7, (%r14) - LONG $0xc0458b48 // movq $-64(%rbp), %rax - WORD $0x394c; BYTE $0xf8 // cmpq %r15, %rax - LONG $0xffc1c748; WORD $0xffff; BYTE $0xff // movq $-1, %rcx - LONG $0xc84c0f48 // cmovlq %rax, %rcx - LONG $0x184e8949 // movq %rcx, $24(%r14) - LONG $0x00026de9; BYTE $0x00 // jmp LBB15_58, $621(%rip) + LONG $0x025e880f; WORD $0x0000 // js LBB11_47, $606(%rip) + LONG $0xd0458948 // movq %rax, $-48(%rbp) + LONG $0x107e894d // movq %r15, $16(%r14) + LONG $0xc04d8b48 // movq $-64(%rbp), %rcx + WORD $0x3948; BYTE $0xc1 // cmpq %rax, %rcx + LONG $0xffc2c748; WORD $0xffff; BYTE $0xff // movq $-1, %rdx + LONG $0xd14c0f48 // cmovlq %rcx, %rdx + LONG $0x18568949 // movq %rdx, $24(%r14) + LONG $0x000007b9; BYTE $0x00 // movl $7, %ecx + WORD $0x8949; BYTE $0x0e // movq %rcx, (%r14) + WORD $0x8948; BYTE $0xc3 // movq %rax, %rbx + LONG $0x00026de9; BYTE $0x00 // jmp LBB11_58, $621(%rip) -LBB15_14: - WORD $0xc031 // xorl %eax, %eax - LONG $0x00c7f741; WORD $0x0000; BYTE $0x80 // testl $-2147483648, %r15d - LONG $0xfec1c748; WORD $0xffff; BYTE $0xff // movq $-2, %rcx - LONG $0x00000bba; BYTE $0x00 // movl $11, %edx - LONG $0x00011ae9; BYTE $0x00 // jmp LBB15_31, $282(%rip) +LBB11_14: + WORD $0x8545; BYTE $0xe4 // testl %r12d, %r12d + LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq $-2, %rax + LONG $0x00000bb9; BYTE $0x00 // movl $11, %ecx + LONG $0x0000e8e9; BYTE $0x00 // jmp LBB11_28, $232(%rip) -LBB15_15: - WORD $0xc031 // xorl %eax, %eax - LONG $0x00c7f741; WORD $0x0000; BYTE $0x80 // testl $-2147483648, %r15d - LONG $0xfec1c748; WORD $0xffff; BYTE $0xff // movq $-2, %rcx - LONG $0x00000aba; BYTE $0x00 // movl $10, %edx - LONG $0x000100e9; BYTE $0x00 // jmp LBB15_31, $256(%rip) +LBB11_15: + WORD $0x8545; BYTE $0xe4 // testl %r12d, %r12d + LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq $-2, %rax + LONG $0x00000ab9; BYTE $0x00 // movl $10, %ecx + LONG $0x0000d4e9; BYTE $0x00 // jmp LBB11_28, $212(%rip) -LBB15_16: +LBB11_16: LONG $0x0506c749; WORD $0x0000; BYTE $0x00 // movq $5, (%r14) - LONG $0xd07d8b4c // movq $-48(%rbp), %r15 - LONG $0x000229e9; BYTE $0x00 // jmp LBB15_58, $553(%rip) - -LBB15_17: - WORD $0xc031 // xorl %eax, %eax - LONG $0x00c7f741; WORD $0x0000; BYTE $0x80 // testl $-2147483648, %r15d - LONG $0xfec1c748; WORD $0xffff; BYTE $0xff // movq $-2, %rcx - LONG $0x00000cba; BYTE $0x00 // movl $12, %edx - LONG $0x0000d6e9; BYTE $0x00 // jmp LBB15_31, $214(%rip) + LONG $0xd05d8b48 // movq $-48(%rbp), %rbx + LONG $0x000235e9; BYTE $0x00 // jmp LBB11_58, $565(%rip) -LBB15_18: - LONG $0xd07d8b4c // movq $-48(%rbp), %r15 - LONG $0xfc4b8d48 // leaq $-4(%rbx), %rcx - LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax - WORD $0x3949; BYTE $0xcf // cmpq %rcx, %r15 - LONG $0x008a870f; WORD $0x0000 // ja LBB15_25, $138(%rip) - LONG $0x3c0c8b43 // movl (%r12,%r15), %ecx - LONG $0x6c61f981; WORD $0x6573 // cmpl $1702063201, %ecx - LONG $0x00d3850f; WORD $0x0000 // jne LBB15_33, $211(%rip) - LONG $0x04c78349 // addq $4, %r15 - LONG $0x000004b8; BYTE $0x00 // movl $4, %eax - LONG $0x000069e9; BYTE $0x00 // jmp LBB15_24, $105(%rip) +LBB11_17: + WORD $0x8545; BYTE $0xe4 // testl %r12d, %r12d + LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq $-2, %rax + LONG $0x00000cb9; BYTE $0x00 // movl $12, %ecx + LONG $0x0000b0e9; BYTE $0x00 // jmp LBB11_28, $176(%rip) -LBB15_21: - LONG $0xd07d8b4c // movq $-48(%rbp), %r15 - LONG $0xfd4b8d48 // leaq $-3(%rbx), %rcx - LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax - WORD $0x3949; BYTE $0xcf // cmpq %rcx, %r15 - LONG $0x0054870f; WORD $0x0000 // ja LBB15_25, $84(%rip) - LONG $0x3c4c8b43; BYTE $0xff // movl $-1(%r12,%r15), %ecx - LONG $0x756ef981; WORD $0x6c6c // cmpl $1819047278, %ecx - LONG $0x00db850f; WORD $0x0000 // jne LBB15_37, $219(%rip) - LONG $0x03c78349 // addq $3, %r15 - LONG $0x000002b8; BYTE $0x00 // movl $2, %eax - LONG $0x000032e9; BYTE $0x00 // jmp LBB15_24, $50(%rip) +LBB11_18: + LONG $0xd04d8b48 // movq $-48(%rbp), %rcx + LONG $0xfc438d48 // leaq $-4(%rbx), %rax + WORD $0x3948; BYTE $0xc1 // cmpq %rax, %rcx + LONG $0x006d870f; WORD $0x0000 // ja LBB11_22, $109(%rip) + LONG $0x0f148b41 // movl (%r15,%rcx), %edx + LONG $0x6c61fa81; WORD $0x6573 // cmpl $1702063201, %edx + LONG $0x00cc850f; WORD $0x0000 // jne LBB11_31, $204(%rip) + LONG $0x04c18348 // addq $4, %rcx + LONG $0xd04d8948 // movq %rcx, $-48(%rbp) + LONG $0x000004b8; BYTE $0x00 // movl $4, %eax + WORD $0x8948; BYTE $0xcb // movq %rcx, %rbx + WORD $0x8949; BYTE $0x06 // movq %rax, (%r14) + LONG $0x0001e8e9; BYTE $0x00 // jmp LBB11_58, $488(%rip) -LBB15_26: - LONG $0xd07d8b4c // movq $-48(%rbp), %r15 - LONG $0xfd4b8d48 // leaq $-3(%rbx), %rcx - LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax - WORD $0x3949; BYTE $0xcf // cmpq %rcx, %r15 - LONG $0x001d870f; WORD $0x0000 // ja LBB15_25, $29(%rip) - LONG $0x3c4c8b43; BYTE $0xff // movl $-1(%r12,%r15), %ecx - LONG $0x7274f981; WORD $0x6575 // cmpl $1702195828, %ecx - LONG $0x00e2850f; WORD $0x0000 // jne LBB15_41, $226(%rip) - LONG $0x03c78349 // addq $3, %r15 - LONG $0x000003b8; BYTE $0x00 // movl $3, %eax +LBB11_21: + LONG $0xd04d8b48 // movq $-48(%rbp), %rcx + LONG $0xfd438d48 // leaq $-3(%rbx), %rax + WORD $0x3948; BYTE $0xc1 // cmpq %rax, %rcx + LONG $0x0034870f; WORD $0x0000 // ja LBB11_22, $52(%rip) + LONG $0x0f548b41; BYTE $0xff // movl $-1(%r15,%rcx), %edx + LONG $0x756efa81; WORD $0x6c6c // cmpl $1819047278, %edx + LONG $0x00d1850f; WORD $0x0000 // jne LBB11_35, $209(%rip) + LONG $0x03c18348 // addq $3, %rcx + LONG $0xd04d8948 // movq %rcx, $-48(%rbp) + LONG $0x000002b8; BYTE $0x00 // movl $2, %eax + LONG $0x000165e9; BYTE $0x00 // jmp LBB11_50, $357(%rip) -LBB15_24: - WORD $0x894c; BYTE $0xfb // movq %r15, %rbx +LBB11_23: + LONG $0xd04d8b48 // movq $-48(%rbp), %rcx + LONG $0xfd438d48 // leaq $-3(%rbx), %rax + WORD $0x3948; BYTE $0xc1 // cmpq %rax, %rcx + LONG $0x004c860f; WORD $0x0000 // jbe LBB11_24, $76(%rip) -LBB15_25: - LONG $0xd05d8948 // movq %rbx, $-48(%rbp) - WORD $0x8949; BYTE $0xdf // movq %rbx, %r15 - WORD $0x8949; BYTE $0x06 // movq %rax, (%r14) - LONG $0x00015ee9; BYTE $0x00 // jmp LBB15_58, $350(%rip) +LBB11_22: + LONG $0xd05d8948 // movq %rbx, $-48(%rbp) + LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax + WORD $0x8949; BYTE $0x06 // movq %rax, (%r14) + LONG $0x000190e9; BYTE $0x00 // jmp LBB11_58, $400(%rip) -LBB15_29: +LBB11_26: LONG $0x0606c749; WORD $0x0000; BYTE $0x00 // movq $6, (%r14) - LONG $0xd07d8b4c // movq $-48(%rbp), %r15 - LONG $0x00014ee9; BYTE $0x00 // jmp LBB15_58, $334(%rip) + LONG $0xd05d8b48 // movq $-48(%rbp), %rbx + LONG $0x000180e9; BYTE $0x00 // jmp LBB11_58, $384(%rip) -LBB15_30: - WORD $0xc031 // xorl %eax, %eax - LONG $0x00c7f741; WORD $0x0000; BYTE $0x80 // testl $-2147483648, %r15d - LONG $0xfec1c748; WORD $0xffff; BYTE $0xff // movq $-2, %rcx - LONG $0x00000dba; BYTE $0x00 // movl $13, %edx +LBB11_27: + WORD $0x8545; BYTE $0xe4 // testl %r12d, %r12d + LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq $-2, %rax + LONG $0x00000db9; BYTE $0x00 // movl $13, %ecx -LBB15_31: - LONG $0xd1440f48 // cmoveq %rcx, %rdx - WORD $0x940f; BYTE $0xc0 // sete %al - WORD $0x8949; BYTE $0x16 // movq %rdx, (%r14) - LONG $0xd07d8b4c // movq $-48(%rbp), %r15 - WORD $0x2949; BYTE $0xc7 // subq %rax, %r15 - LONG $0x000123e9; BYTE $0x00 // jmp LBB15_58, $291(%rip) +LBB11_28: + LONG $0xc8490f48 // cmovnsq %rax, %rcx + WORD $0x8949; BYTE $0x0e // movq %rcx, (%r14) + LONG $0x1ffcc141 // sarl $31, %r12d + WORD $0xf741; BYTE $0xd4 // notl %r12d + WORD $0x6349; BYTE $0xdc // movslq %r12d, %rbx + LONG $0xd05d0348 // addq $-48(%rbp), %rbx + LONG $0x000157e9; BYTE $0x00 // jmp LBB11_58, $343(%rip) -LBB15_32: - LONG $0xd05d8948 // movq %rbx, $-48(%rbp) - WORD $0x894d; BYTE $0x3e // movq %r15, (%r14) - WORD $0x8949; BYTE $0xdf // movq %rbx, %r15 - LONG $0x000114e9; BYTE $0x00 // jmp LBB15_58, $276(%rip) +LBB11_24: + LONG $0x0f548b41; BYTE $0xff // movl $-1(%r15,%rcx), %edx + LONG $0x7274fa81; WORD $0x6575 // cmpl $1702195828, %edx + LONG $0x0097850f; WORD $0x0000 // jne LBB11_39, $151(%rip) + LONG $0x03c18348 // addq $3, %rcx + LONG $0xd04d8948 // movq %rcx, $-48(%rbp) + LONG $0x000003b8; BYTE $0x00 // movl $3, %eax + LONG $0x0000e5e9; BYTE $0x00 // jmp LBB11_50, $229(%rip) -LBB15_33: +LBB11_31: LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq $-2, %rax - WORD $0xf980; BYTE $0x61 // cmpb $97, %cl - LONG $0x00d5850f; WORD $0x0000 // jne LBB15_49, $213(%rip) - LONG $0x3c7c8043; WORD $0x6c01 // cmpb $108, $1(%r12,%r15) - LONG $0x00aa850f; WORD $0x0000 // jne LBB15_46, $170(%rip) - LONG $0x3c7c8043; WORD $0x7302 // cmpb $115, $2(%r12,%r15) - LONG $0x00b5850f; WORD $0x0000 // jne LBB15_47, $181(%rip) - LONG $0x044f8d49 // leaq $4(%r15), %rcx - LONG $0x3c7c8043; WORD $0x6503 // cmpb $101, $3(%r12,%r15) - LONG $0x037f8d4d // leaq $3(%r15), %r15 - LONG $0xf9440f4c // cmoveq %rcx, %r15 - LONG $0x0000a2e9; BYTE $0x00 // jmp LBB15_48, $162(%rip) + WORD $0xfa80; BYTE $0x61 // cmpb $97, %dl + LONG $0x00bb850f; WORD $0x0000 // jne LBB11_43, $187(%rip) + LONG $0x0f7c8041; WORD $0x6c01 // cmpb $108, $1(%r15,%rcx) + LONG $0x00ba850f; WORD $0x0000 // jne LBB11_44, $186(%rip) + LONG $0x0f7c8041; WORD $0x7302 // cmpb $115, $2(%r15,%rcx) + LONG $0x00c8850f; WORD $0x0000 // jne LBB11_45, $200(%rip) + LONG $0x03598d48 // leaq $3(%rcx), %rbx + LONG $0x04518d48 // leaq $4(%rcx), %rdx + LONG $0x0f7c8041; WORD $0x6503 // cmpb $101, $3(%r15,%rcx) + LONG $0xda440f48 // cmoveq %rdx, %rbx + LONG $0x0000b8e9; BYTE $0x00 // jmp LBB11_47, $184(%rip) -LBB15_37: +LBB11_35: + LONG $0xff598d48 // leaq $-1(%rcx), %rbx + LONG $0xd05d8948 // movq %rbx, $-48(%rbp) LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq $-2, %rax - WORD $0xf980; BYTE $0x6e // cmpb $110, %cl - LONG $0x006c850f; WORD $0x0000 // jne LBB15_45, $108(%rip) - LONG $0x3c3c8043; BYTE $0x75 // cmpb $117, (%r12,%r15) - LONG $0x0077850f; WORD $0x0000 // jne LBB15_51, $119(%rip) - LONG $0x3c7c8043; WORD $0x6c01 // cmpb $108, $1(%r12,%r15) - LONG $0x0068850f; WORD $0x0000 // jne LBB15_50, $104(%rip) - LONG $0x034f8d49 // leaq $3(%r15), %rcx - LONG $0x3c7c8043; WORD $0x6c02 // cmpb $108, $2(%r12,%r15) - LONG $0x027f8d4d // leaq $2(%r15), %r15 - LONG $0xf9440f4c // cmoveq %rcx, %r15 - LONG $0x000054e9; BYTE $0x00 // jmp LBB15_51, $84(%rip) - -LBB15_41: + WORD $0xfa80; BYTE $0x6e // cmpb $110, %dl + LONG $0x0091850f; WORD $0x0000 // jne LBB11_51, $145(%rip) + LONG $0x0f3c8041; BYTE $0x75 // cmpb $117, (%r15,%rcx) + LONG $0x007f850f; WORD $0x0000 // jne LBB11_49, $127(%rip) + LONG $0x0f7c8041; WORD $0x6c01 // cmpb $108, $1(%r15,%rcx) + LONG $0x0070850f; WORD $0x0000 // jne LBB11_48, $112(%rip) + LONG $0x0f7c8041; WORD $0x6c02 // cmpb $108, $2(%r15,%rcx) + LONG $0x03518d48 // leaq $3(%rcx), %rdx + LONG $0x02498d48 // leaq $2(%rcx), %rcx + LONG $0xca440f48 // cmoveq %rdx, %rcx + LONG $0x00005ce9; BYTE $0x00 // jmp LBB11_49, $92(%rip) + +LBB11_39: + LONG $0xff598d48 // leaq $-1(%rcx), %rbx + LONG $0xd05d8948 // movq %rbx, $-48(%rbp) LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq $-2, %rax - WORD $0xf980; BYTE $0x74 // cmpb $116, %cl - LONG $0x002e850f; WORD $0x0000 // jne LBB15_45, $46(%rip) - LONG $0x3c3c8043; BYTE $0x72 // cmpb $114, (%r12,%r15) - LONG $0x0039850f; WORD $0x0000 // jne LBB15_51, $57(%rip) - LONG $0x3c7c8043; WORD $0x7501 // cmpb $117, $1(%r12,%r15) - LONG $0x002a850f; WORD $0x0000 // jne LBB15_50, $42(%rip) - LONG $0x034f8d49 // leaq $3(%r15), %rcx - LONG $0x3c7c8043; WORD $0x6502 // cmpb $101, $2(%r12,%r15) - LONG $0x027f8d4d // leaq $2(%r15), %r15 - LONG $0xf9440f4c // cmoveq %rcx, %r15 - LONG $0x000016e9; BYTE $0x00 // jmp LBB15_51, $22(%rip) + WORD $0xfa80; BYTE $0x74 // cmpb $116, %dl + LONG $0x004b850f; WORD $0x0000 // jne LBB11_51, $75(%rip) + LONG $0x0f3c8041; BYTE $0x72 // cmpb $114, (%r15,%rcx) + LONG $0x0039850f; WORD $0x0000 // jne LBB11_49, $57(%rip) + LONG $0x0f7c8041; WORD $0x7501 // cmpb $117, $1(%r15,%rcx) + LONG $0x002a850f; WORD $0x0000 // jne LBB11_48, $42(%rip) + LONG $0x0f7c8041; WORD $0x6502 // cmpb $101, $2(%r15,%rcx) + LONG $0x03518d48 // leaq $3(%rcx), %rdx + LONG $0x02498d48 // leaq $2(%rcx), %rcx + LONG $0xca440f48 // cmoveq %rdx, %rcx + LONG $0x000016e9; BYTE $0x00 // jmp LBB11_49, $22(%rip) -LBB15_45: - WORD $0xff49; BYTE $0xcf // decq %r15 +LBB11_43: + WORD $0x8948; BYTE $0xcb // movq %rcx, %rbx WORD $0x8949; BYTE $0x06 // movq %rax, (%r14) - LONG $0x00004ee9; BYTE $0x00 // jmp LBB15_58, $78(%rip) + LONG $0x00005ee9; BYTE $0x00 // jmp LBB11_58, $94(%rip) -LBB15_46: - WORD $0xff49; BYTE $0xc7 // incq %r15 - LONG $0x000013e9; BYTE $0x00 // jmp LBB15_48, $19(%rip) +LBB11_44: + WORD $0xff48; BYTE $0xc1 // incq %rcx + LONG $0x000016e9; BYTE $0x00 // jmp LBB11_46, $22(%rip) -LBB15_50: - WORD $0xff49; BYTE $0xc7 // incq %r15 +LBB11_48: + WORD $0xff48; BYTE $0xc1 // incq %rcx -LBB15_51: - LONG $0xd07d894c // movq %r15, $-48(%rbp) +LBB11_49: + LONG $0xd04d8948 // movq %rcx, $-48(%rbp) + +LBB11_50: + WORD $0x8948; BYTE $0xcb // movq %rcx, %rbx + +LBB11_51: WORD $0x8949; BYTE $0x06 // movq %rax, (%r14) - LONG $0x000037e9; BYTE $0x00 // jmp LBB15_58, $55(%rip) + LONG $0x000044e9; BYTE $0x00 // jmp LBB11_58, $68(%rip) -LBB15_47: - LONG $0x02c78349 // addq $2, %r15 +LBB11_45: + LONG $0x02c18348 // addq $2, %rcx -LBB15_48: - LONG $0xd07d894c // movq %r15, $-48(%rbp) +LBB11_46: + WORD $0x8948; BYTE $0xcb // movq %rcx, %rbx -LBB15_49: +LBB11_47: + LONG $0xd05d8948 // movq %rbx, $-48(%rbp) WORD $0x8949; BYTE $0x06 // movq %rax, (%r14) - LONG $0x000027e9; BYTE $0x00 // jmp LBB15_58, $39(%rip) + LONG $0x000031e9; BYTE $0x00 // jmp LBB11_58, $49(%rip) -LBB15_53: +LBB11_53: + WORD $0x294d; BYTE $0xfc // subq %r15, %r12 + LONG $0xd065894c // movq %r12, $-48(%rbp) LONG $0xffc5c749; WORD $0xffff; BYTE $0xff // movq $-1, %r13 - LONG $0x00000de9; BYTE $0x00 // jmp LBB15_56, $13(%rip) + LONG $0x000014e9; BYTE $0x00 // jmp LBB11_56, $20(%rip) -LBB15_54: +LBB11_54: WORD $0xf748; BYTE $0xd0 // notq %rax - WORD $0x0149; BYTE $0xc7 // addq %rax, %r15 + WORD $0x0149; BYTE $0xc4 // addq %rax, %r12 -LBB15_55: +LBB11_55: + WORD $0x294d; BYTE $0xfc // subq %r15, %r12 + LONG $0xd065894c // movq %r12, $-48(%rbp) LONG $0xfec5c749; WORD $0xffff; BYTE $0xff // movq $-2, %r13 -LBB15_56: - WORD $0x294d; BYTE $0xe7 // subq %r12, %r15 - LONG $0xd07d894c // movq %r15, $-48(%rbp) +LBB11_56: + WORD $0x894c; BYTE $0xe3 // movq %r12, %rbx -LBB15_57: +LBB11_57: LONG $0xc8458b48 // movq $-56(%rbp), %rax WORD $0x894c; BYTE $0x28 // movq %r13, (%rax) -LBB15_58: - WORD $0x894c; BYTE $0xf8 // movq %r15, %rax +LBB11_58: + WORD $0x8948; BYTE $0xd8 // movq %rbx, %rax LONG $0x28c48348 // addq $40, %rsp BYTE $0x5b // popq %rbx WORD $0x5c41 // popq %r12 @@ -5032,409 +4601,325 @@ LBB15_58: BYTE $0xc3 // retq WORD $0x9090; BYTE $0x90 // .p2align 2, 0x90 - // .set L15_0_set_10, LBB15_10-LJTI15_0 - // .set L15_0_set_11, LBB15_11-LJTI15_0 - // .set L15_0_set_12, LBB15_12-LJTI15_0 - // .set L15_0_set_14, LBB15_14-LJTI15_0 - // .set L15_0_set_2, LBB15_2-LJTI15_0 - // .set L15_0_set_15, LBB15_15-LJTI15_0 - // .set L15_0_set_16, LBB15_16-LJTI15_0 - // .set L15_0_set_17, LBB15_17-LJTI15_0 - // .set L15_0_set_18, LBB15_18-LJTI15_0 - // .set L15_0_set_21, LBB15_21-LJTI15_0 - // .set L15_0_set_26, LBB15_26-LJTI15_0 - // .set L15_0_set_29, LBB15_29-LJTI15_0 - // .set L15_0_set_30, LBB15_30-LJTI15_0 -LJTI15_0: - LONG $0xfffffd06 // .long L15_0_set_10 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd29 // .long L15_0_set_12 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd7e // .long L15_0_set_14 - LONG $0xfffffc6a // .long L15_0_set_2 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffc6a // .long L15_0_set_2 - LONG $0xfffffc6a // .long L15_0_set_2 - LONG $0xfffffc6a // .long L15_0_set_2 - LONG $0xfffffc6a // .long L15_0_set_2 - LONG $0xfffffc6a // .long L15_0_set_2 - LONG $0xfffffc6a // .long L15_0_set_2 - LONG $0xfffffc6a // .long L15_0_set_2 - LONG $0xfffffc6a // .long L15_0_set_2 - LONG $0xfffffc6a // .long L15_0_set_2 - LONG $0xfffffc6a // .long L15_0_set_2 - LONG $0xfffffd98 // .long L15_0_set_15 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffdb2 // .long L15_0_set_16 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffdc2 // .long L15_0_set_17 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffddc // .long L15_0_set_18 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffe12 // .long L15_0_set_21 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffe49 // .long L15_0_set_26 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffe8d // .long L15_0_set_29 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffe9d // .long L15_0_set_30 - QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .p2align 5, 0x00 - -LCPI16_0: - QUAD $0x2020202020202020; QUAD $0x2020202020202020 // .space 16, ' ' - QUAD $0x2020202020202020; QUAD $0x2020202020202020 // .space 16, ' ' - -LCPI16_1: - QUAD $0x0909090909090909; QUAD $0x0909090909090909 // .space 16, '\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t' - QUAD $0x0909090909090909; QUAD $0x0909090909090909 // .space 16, '\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t' - -LCPI16_2: - QUAD $0x0a0a0a0a0a0a0a0a; QUAD $0x0a0a0a0a0a0a0a0a // .space 16, '\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n' - QUAD $0x0a0a0a0a0a0a0a0a; QUAD $0x0a0a0a0a0a0a0a0a // .space 16, '\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n' - -LCPI16_3: - QUAD $0x0d0d0d0d0d0d0d0d; QUAD $0x0d0d0d0d0d0d0d0d // .space 16, '\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r' - QUAD $0x0d0d0d0d0d0d0d0d; QUAD $0x0d0d0d0d0d0d0d0d // .space 16, '\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r' - - // .p2align 4, 0x00 -LCPI16_4: - QUAD $0x2020202020202020; QUAD $0x2020202020202020 // .space 16, ' ' - -LCPI16_5: - QUAD $0x0909090909090909; QUAD $0x0909090909090909 // .space 16, '\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t' - -LCPI16_6: - QUAD $0x0a0a0a0a0a0a0a0a; QUAD $0x0a0a0a0a0a0a0a0a // .space 16, '\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n' - -LCPI16_7: - QUAD $0x0d0d0d0d0d0d0d0d; QUAD $0x0d0d0d0d0d0d0d0d // .space 16, '\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r' + // .set L11_0_set_10, LBB11_10-LJTI11_0 + // .set L11_0_set_11, LBB11_11-LJTI11_0 + // .set L11_0_set_12, LBB11_12-LJTI11_0 + // .set L11_0_set_14, LBB11_14-LJTI11_0 + // .set L11_0_set_2, LBB11_2-LJTI11_0 + // .set L11_0_set_15, LBB11_15-LJTI11_0 + // .set L11_0_set_16, LBB11_16-LJTI11_0 + // .set L11_0_set_17, LBB11_17-LJTI11_0 + // .set L11_0_set_18, LBB11_18-LJTI11_0 + // .set L11_0_set_21, LBB11_21-LJTI11_0 + // .set L11_0_set_23, LBB11_23-LJTI11_0 + // .set L11_0_set_26, LBB11_26-LJTI11_0 + // .set L11_0_set_27, LBB11_27-LJTI11_0 +LJTI11_0: + LONG $0xfffffd05 // .long L11_0_set_10 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd28 // .long L11_0_set_12 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd7e // .long L11_0_set_14 + LONG $0xfffffc62 // .long L11_0_set_2 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffc62 // .long L11_0_set_2 + LONG $0xfffffc62 // .long L11_0_set_2 + LONG $0xfffffc62 // .long L11_0_set_2 + LONG $0xfffffc62 // .long L11_0_set_2 + LONG $0xfffffc62 // .long L11_0_set_2 + LONG $0xfffffc62 // .long L11_0_set_2 + LONG $0xfffffc62 // .long L11_0_set_2 + LONG $0xfffffc62 // .long L11_0_set_2 + LONG $0xfffffc62 // .long L11_0_set_2 + LONG $0xfffffc62 // .long L11_0_set_2 + LONG $0xfffffd92 // .long L11_0_set_15 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffda6 // .long L11_0_set_16 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffdb6 // .long L11_0_set_17 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffdca // .long L11_0_set_18 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffe03 // .long L11_0_set_21 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffe37 // .long L11_0_set_23 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffe5b // .long L11_0_set_26 + LONG $0xfffffd15 // .long L11_0_set_11 + LONG $0xfffffe6b // .long L11_0_set_27 + QUAD $0x0000000000000000; LONG $0x00000000 // .p2align 5, 0x00 + +LCPI12_0: + BYTE $0x20 // .byte 32 + BYTE $0x00 // .byte 0 + BYTE $0x00 // .byte 0 + BYTE $0x00 // .byte 0 + BYTE $0x00 // .byte 0 + BYTE $0x00 // .byte 0 + BYTE $0x00 // .byte 0 + BYTE $0x00 // .byte 0 + BYTE $0x00 // .byte 0 + BYTE $0x09 // .byte 9 + BYTE $0x0a // .byte 10 + BYTE $0x00 // .byte 0 + BYTE $0x00 // .byte 0 + BYTE $0x0d // .byte 13 + BYTE $0x00 // .byte 0 + BYTE $0x00 // .byte 0 + BYTE $0x20 // .byte 32 + BYTE $0x00 // .byte 0 + BYTE $0x00 // .byte 0 + BYTE $0x00 // .byte 0 + BYTE $0x00 // .byte 0 + BYTE $0x00 // .byte 0 + BYTE $0x00 // .byte 0 + BYTE $0x00 // .byte 0 + BYTE $0x00 // .byte 0 + BYTE $0x09 // .byte 9 + BYTE $0x0a // .byte 10 + BYTE $0x00 // .byte 0 + BYTE $0x00 // .byte 0 + BYTE $0x0d // .byte 13 + BYTE $0x00 // .byte 0 + BYTE $0x00 // .byte 0 // .p2align 4, 0x90 _advance_ns: BYTE $0x55 // pushq %rbp WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp - BYTE $0x53 // pushq %rbx - WORD $0x8b4c; BYTE $0x1e // movq (%rsi), %r11 - WORD $0x8b4c; BYTE $0x0f // movq (%rdi), %r9 - LONG $0x08478b4c // movq $8(%rdi), %r8 - WORD $0x394d; BYTE $0xc3 // cmpq %r8, %r11 - LONG $0x0021830f; WORD $0x0000 // jae LBB16_4, $33(%rip) - LONG $0x04b60f43; BYTE $0x19 // movzbl (%r9,%r11), %eax - WORD $0xf883; BYTE $0x0d // cmpl $13, %eax - LONG $0x0013840f; WORD $0x0000 // je LBB16_4, $19(%rip) - WORD $0xf883; BYTE $0x20 // cmpl $32, %eax - LONG $0x000a840f; WORD $0x0000 // je LBB16_4, $10(%rip) - WORD $0xf504 // addb $-11, %al - WORD $0xfe3c // cmpb $-2, %al - LONG $0x0284820f; WORD $0x0000 // jb LBB16_48, $644(%rip) - -LBB16_4: - LONG $0x01438d49 // leaq $1(%r11), %rax - WORD $0x394c; BYTE $0xc0 // cmpq %r8, %rax - LONG $0x0023830f; WORD $0x0000 // jae LBB16_9, $35(%rip) - LONG $0x0cb60f41; BYTE $0x01 // movzbl (%r9,%rax), %ecx - WORD $0xf983; BYTE $0x0d // cmpl $13, %ecx - LONG $0x0015840f; WORD $0x0000 // je LBB16_9, $21(%rip) - WORD $0xf983; BYTE $0x20 // cmpl $32, %ecx - LONG $0x000c840f; WORD $0x0000 // je LBB16_9, $12(%rip) - WORD $0xc180; BYTE $0xf5 // addb $-11, %cl - WORD $0xf980; BYTE $0xfe // cmpb $-2, %cl - LONG $0x0060820f; WORD $0x0000 // jb LBB16_8, $96(%rip) - -LBB16_9: - LONG $0x02438d49 // leaq $2(%r11), %rax - WORD $0x394c; BYTE $0xc0 // cmpq %r8, %rax - LONG $0x0023830f; WORD $0x0000 // jae LBB16_14, $35(%rip) - LONG $0x0cb60f41; BYTE $0x01 // movzbl (%r9,%rax), %ecx - WORD $0xf983; BYTE $0x0d // cmpl $13, %ecx - LONG $0x0015840f; WORD $0x0000 // je LBB16_14, $21(%rip) - WORD $0xf983; BYTE $0x20 // cmpl $32, %ecx - LONG $0x000c840f; WORD $0x0000 // je LBB16_14, $12(%rip) - WORD $0xc180; BYTE $0xf5 // addb $-11, %cl - WORD $0xf980; BYTE $0xfe // cmpb $-2, %cl - LONG $0x0030820f; WORD $0x0000 // jb LBB16_8, $48(%rip) - -LBB16_14: - LONG $0x03438d49 // leaq $3(%r11), %rax - WORD $0x394c; BYTE $0xc0 // cmpq %r8, %rax - LONG $0x002b830f; WORD $0x0000 // jae LBB16_19, $43(%rip) - LONG $0x0cb60f41; BYTE $0x01 // movzbl (%r9,%rax), %ecx - WORD $0xf983; BYTE $0x0d // cmpl $13, %ecx - LONG $0x001d840f; WORD $0x0000 // je LBB16_19, $29(%rip) - WORD $0xf983; BYTE $0x20 // cmpl $32, %ecx - LONG $0x0014840f; WORD $0x0000 // je LBB16_19, $20(%rip) - WORD $0xc180; BYTE $0xf5 // addb $-11, %cl - WORD $0xf980; BYTE $0xfe // cmpb $-2, %cl - LONG $0x0008830f; WORD $0x0000 // jae LBB16_19, $8(%rip) - -LBB16_8: - WORD $0x8949; BYTE $0xc3 // movq %rax, %r11 - LONG $0x0001ece9; BYTE $0x00 // jmp LBB16_48, $492(%rip) - -LBB16_19: - LONG $0x04c38349 // addq $4, %r11 - WORD $0x394d; BYTE $0xd8 // cmpq %r11, %r8 - LONG $0x01bf860f; WORD $0x0000 // jbe LBB16_44, $447(%rip) - LONG $0x191c8d4b // leaq (%r9,%r11), %rbx - WORD $0x894c; BYTE $0xc1 // movq %r8, %rcx - WORD $0x294c; BYTE $0xd9 // subq %r11, %rcx - LONG $0x0068840f; WORD $0x0000 // je LBB16_28, $104(%rip) - WORD $0xd889 // movl %ebx, %eax - WORD $0xe083; BYTE $0x1f // andl $31, %eax - LONG $0x005d840f; WORD $0x0000 // je LBB16_28, $93(%rip) - LONG $0x000005ba; BYTE $0x00 // movl $5, %edx - WORD $0x294c; BYTE $0xc2 // subq %r8, %rdx - QUAD $0x000100002600b948; WORD $0x0000 // movabsq $4294977024, %rcx - LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 - -LBB16_23: - LONG $0x04be0f43; BYTE $0x19 // movsbl (%r9,%r11), %eax - WORD $0xf883; BYTE $0x20 // cmpl $32, %eax - LONG $0x0193870f; WORD $0x0000 // ja LBB16_46, $403(%rip) - LONG $0xc1a30f48 // btq %rax, %rcx - LONG $0x0189830f; WORD $0x0000 // jae LBB16_46, $393(%rip) - LONG $0x1a1c8d4a // leaq (%rdx,%r11), %rbx - LONG $0x01438d49 // leaq $1(%r11), %rax - LONG $0x04fb8348 // cmpq $4, %rbx - LONG $0x0012840f; WORD $0x0000 // je LBB16_27, $18(%rip) - LONG $0x191c8d43 // leal (%r9,%r11), %ebx - WORD $0xc3ff // incl %ebx - WORD $0x8949; BYTE $0xc3 // movq %rax, %r11 - WORD $0xe383; BYTE $0x1f // andl $31, %ebx - LONG $0xffc4850f; WORD $0xffff // jne LBB16_23, $-60(%rip) - -LBB16_27: - LONG $0x011c8d49 // leaq (%r9,%rax), %rbx - WORD $0x894c; BYTE $0xc1 // movq %r8, %rcx - WORD $0x2948; BYTE $0xc1 // subq %rax, %rcx - -LBB16_28: - LONG $0x20f98348 // cmpq $32, %rcx - LONG $0x0073820f; WORD $0x0000 // jb LBB16_32, $115(%rip) - WORD $0x894c; BYTE $0xc8 // movq %r9, %rax - WORD $0x2948; BYTE $0xd8 // subq %rbx, %rax - QUAD $0xfffffdd2056ffdc5 // vmovdqa $-558(%rip), %ymm0 /* LCPI16_0(%rip) */ - QUAD $0xfffffdea0d6ffdc5 // vmovdqa $-534(%rip), %ymm1 /* LCPI16_1(%rip) */ - QUAD $0xfffffe02156ffdc5 // vmovdqa $-510(%rip), %ymm2 /* LCPI16_2(%rip) */ - QUAD $0xfffffe1a1d6ffdc5 // vmovdqa $-486(%rip), %ymm3 /* LCPI16_3(%rip) */ - QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90 + WORD $0x8b4c; BYTE $0x02 // movq (%rdx), %r8 + WORD $0x3949; BYTE $0xf0 // cmpq %rsi, %r8 + LONG $0x0026830f; WORD $0x0000 // jae LBB12_6, $38(%rip) + LONG $0x07048a42 // movb (%rdi,%r8), %al + WORD $0x0d3c // cmpb $13, %al + LONG $0x001a840f; WORD $0x0000 // je LBB12_6, $26(%rip) + WORD $0x203c // cmpb $32, %al + LONG $0x0012840f; WORD $0x0000 // je LBB12_6, $18(%rip) + WORD $0xf704 // addb $-9, %al + WORD $0x013c // cmpb $1, %al + LONG $0x0008860f; WORD $0x0000 // jbe LBB12_6, $8(%rip) + WORD $0x894d; BYTE $0xc2 // movq %r8, %r10 + LONG $0x00015be9; BYTE $0x00 // jmp LBB12_5, $347(%rip) + +LBB12_6: + LONG $0x01508d4d // leaq $1(%r8), %r10 + WORD $0x3949; BYTE $0xf2 // cmpq %rsi, %r10 + LONG $0x0022830f; WORD $0x0000 // jae LBB12_10, $34(%rip) + LONG $0x170c8a42 // movb (%rdi,%r10), %cl + WORD $0xf980; BYTE $0x0d // cmpb $13, %cl + LONG $0x0015840f; WORD $0x0000 // je LBB12_10, $21(%rip) + WORD $0xf980; BYTE $0x20 // cmpb $32, %cl + LONG $0x000c840f; WORD $0x0000 // je LBB12_10, $12(%rip) + WORD $0xc180; BYTE $0xf7 // addb $-9, %cl + WORD $0xf980; BYTE $0x01 // cmpb $1, %cl + LONG $0x012c870f; WORD $0x0000 // ja LBB12_5, $300(%rip) + +LBB12_10: + LONG $0x02508d4d // leaq $2(%r8), %r10 + WORD $0x3949; BYTE $0xf2 // cmpq %rsi, %r10 + LONG $0x0022830f; WORD $0x0000 // jae LBB12_14, $34(%rip) + LONG $0x170c8a42 // movb (%rdi,%r10), %cl + WORD $0xf980; BYTE $0x0d // cmpb $13, %cl + LONG $0x0015840f; WORD $0x0000 // je LBB12_14, $21(%rip) + WORD $0xf980; BYTE $0x20 // cmpb $32, %cl + LONG $0x000c840f; WORD $0x0000 // je LBB12_14, $12(%rip) + WORD $0xc180; BYTE $0xf7 // addb $-9, %cl + WORD $0xf980; BYTE $0x01 // cmpb $1, %cl + LONG $0x00fd870f; WORD $0x0000 // ja LBB12_5, $253(%rip) + +LBB12_14: + LONG $0x03508d4d // leaq $3(%r8), %r10 + WORD $0x3949; BYTE $0xf2 // cmpq %rsi, %r10 + LONG $0x0022830f; WORD $0x0000 // jae LBB12_18, $34(%rip) + LONG $0x170c8a42 // movb (%rdi,%r10), %cl + WORD $0xf980; BYTE $0x0d // cmpb $13, %cl + LONG $0x0015840f; WORD $0x0000 // je LBB12_18, $21(%rip) + WORD $0xf980; BYTE $0x20 // cmpb $32, %cl + LONG $0x000c840f; WORD $0x0000 // je LBB12_18, $12(%rip) + WORD $0xc180; BYTE $0xf7 // addb $-9, %cl + WORD $0xf980; BYTE $0x01 // cmpb $1, %cl + LONG $0x00ce870f; WORD $0x0000 // ja LBB12_5, $206(%rip) + +LBB12_18: + LONG $0x04c08349 // addq $4, %r8 + WORD $0x3949; BYTE $0xf0 // cmpq %rsi, %r8 + LONG $0x00a2830f; WORD $0x0000 // jae LBB12_19, $162(%rip) + LONG $0x07148d4e // leaq (%rdi,%r8), %r10 + WORD $0x8948; BYTE $0xf1 // movq %rsi, %rcx + WORD $0x294c; BYTE $0xc1 // subq %r8, %rcx + LONG $0x20f98348 // cmpq $32, %rcx + LONG $0x0039820f; WORD $0x0000 // jb LBB12_25, $57(%rip) + QUAD $0xfffffef4056ffdc5 // vmovdqa $-268(%rip), %ymm0 /* LCPI12_0(%rip) */ + LONG $0x90909090 // .p2align 4, 0x90 -LBB16_30: - LONG $0x236ffdc5 // vmovdqa (%rbx), %ymm4 - LONG $0xe874ddc5 // vpcmpeqb %ymm0, %ymm4, %ymm5 - LONG $0xf174ddc5 // vpcmpeqb %ymm1, %ymm4, %ymm6 - LONG $0xeeebd5c5 // vpor %ymm6, %ymm5, %ymm5 - LONG $0xf274ddc5 // vpcmpeqb %ymm2, %ymm4, %ymm6 - LONG $0xe374ddc5 // vpcmpeqb %ymm3, %ymm4, %ymm4 - LONG $0xe6ebddc5 // vpor %ymm6, %ymm4, %ymm4 - LONG $0xe5ebddc5 // vpor %ymm5, %ymm4, %ymm4 - LONG $0xd4d7fdc5 // vpmovmskb %ymm4, %edx - WORD $0xfa83; BYTE $0xff // cmpl $-1, %edx - LONG $0x00e8850f; WORD $0x0000 // jne LBB16_45, $232(%rip) - LONG $0x20c38348 // addq $32, %rbx +LBB12_22: + LONG $0x6f7ec1c4; BYTE $0x0a // vmovdqu (%r10), %ymm1 + LONG $0x007de2c4; BYTE $0xd1 // vpshufb %ymm1, %ymm0, %ymm2 + LONG $0xca74f5c5 // vpcmpeqb %ymm2, %ymm1, %ymm1 + LONG $0xc1d7fdc5 // vpmovmskb %ymm1, %eax + WORD $0xf883; BYTE $0xff // cmpl $-1, %eax + LONG $0x006f850f; WORD $0x0000 // jne LBB12_23, $111(%rip) + LONG $0x20c28349 // addq $32, %r10 LONG $0xe0c18348 // addq $-32, %rcx - LONG $0xe0c08348 // addq $-32, %rax LONG $0x1ff98348 // cmpq $31, %rcx - LONG $0xffbd870f; WORD $0xffff // ja LBB16_30, $-67(%rip) + LONG $0xffd3870f; WORD $0xffff // ja LBB12_22, $-45(%rip) -LBB16_32: - WORD $0xf8c5; BYTE $0x77 // vzeroupper - LONG $0x10f98348 // cmpq $16, %rcx - LONG $0x006a820f; WORD $0x0000 // jb LBB16_36, $106(%rip) - WORD $0x894d; BYTE $0xca // movq %r9, %r10 - WORD $0x2949; BYTE $0xda // subq %rbx, %r10 - QUAD $0xfffffdd2056ff9c5 // vmovdqa $-558(%rip), %xmm0 /* LCPI16_4(%rip) */ - QUAD $0xfffffdda0d6ff9c5 // vmovdqa $-550(%rip), %xmm1 /* LCPI16_5(%rip) */ - QUAD $0xfffffde2156ff9c5 // vmovdqa $-542(%rip), %xmm2 /* LCPI16_6(%rip) */ - QUAD $0xfffffdea1d6ff9c5 // vmovdqa $-534(%rip), %xmm3 /* LCPI16_7(%rip) */ - -LBB16_34: - LONG $0x236ff9c5 // vmovdqa (%rbx), %xmm4 - LONG $0xe874d9c5 // vpcmpeqb %xmm0, %xmm4, %xmm5 - LONG $0xf174d9c5 // vpcmpeqb %xmm1, %xmm4, %xmm6 - LONG $0xeeebd1c5 // vpor %xmm6, %xmm5, %xmm5 - LONG $0xf274d9c5 // vpcmpeqb %xmm2, %xmm4, %xmm6 - LONG $0xe374d9c5 // vpcmpeqb %xmm3, %xmm4, %xmm4 - LONG $0xe6ebd9c5 // vpor %xmm6, %xmm4, %xmm4 - LONG $0xe5ebd9c5 // vpor %xmm5, %xmm4, %xmm4 - LONG $0xc4d7f9c5 // vpmovmskb %xmm4, %eax - LONG $0xfff88366 // cmpw $-1, %ax - LONG $0x009b850f; WORD $0x0000 // jne LBB16_49, $155(%rip) - LONG $0x10c38348 // addq $16, %rbx - LONG $0xf0c18348 // addq $-16, %rcx - LONG $0xf0c28349 // addq $-16, %r10 - LONG $0x0ff98348 // cmpq $15, %rcx - LONG $0xffbc870f; WORD $0xffff // ja LBB16_34, $-68(%rip) - -LBB16_36: +LBB12_25: WORD $0x8548; BYTE $0xc9 // testq %rcx, %rcx - LONG $0x0036840f; WORD $0x0000 // je LBB16_42, $54(%rip) - LONG $0x0b148d4c // leaq (%rbx,%rcx), %r10 - WORD $0xc031 // xorl %eax, %eax - QUAD $0x000100002600bb49; WORD $0x0000 // movabsq $4294977024, %r11 - -LBB16_38: - LONG $0x0314be0f // movsbl (%rbx,%rax), %edx - WORD $0xfa83; BYTE $0x20 // cmpl $32, %edx - LONG $0x007c870f; WORD $0x0000 // ja LBB16_51, $124(%rip) - LONG $0xd3a30f49 // btq %rdx, %r11 - LONG $0x0072830f; WORD $0x0000 // jae LBB16_51, $114(%rip) - WORD $0xff48; BYTE $0xc0 // incq %rax - WORD $0x3948; BYTE $0xc1 // cmpq %rax, %rcx - LONG $0xffdd850f; WORD $0xffff // jne LBB16_38, $-35(%rip) - WORD $0x894c; BYTE $0xd3 // movq %r10, %rbx + LONG $0x003b840f; WORD $0x0000 // je LBB12_32, $59(%rip) + LONG $0x0a048d4d // leaq (%r10,%rcx), %r8 + WORD $0xff49; BYTE $0xc2 // incq %r10 + QUAD $0x000100002600b949; WORD $0x0000 // movabsq $4294977024, %r9 -LBB16_42: - WORD $0x294c; BYTE $0xcb // subq %r9, %rbx - WORD $0x8949; BYTE $0xdb // movq %rbx, %r11 - WORD $0x394d; BYTE $0xc3 // cmpq %r8, %r11 - LONG $0x0022820f; WORD $0x0000 // jb LBB16_47, $34(%rip) - LONG $0x000047e9; BYTE $0x00 // jmp LBB16_50, $71(%rip) +LBB12_27: + LONG $0x42be0f41; BYTE $0xff // movsbl $-1(%r10), %eax + WORD $0xf883; BYTE $0x20 // cmpl $32, %eax + LONG $0x005f870f; WORD $0x0000 // ja LBB12_29, $95(%rip) + LONG $0xc1a30f49 // btq %rax, %r9 + LONG $0x0055830f; WORD $0x0000 // jae LBB12_29, $85(%rip) + WORD $0xff48; BYTE $0xc9 // decq %rcx + WORD $0xff49; BYTE $0xc2 // incq %r10 + WORD $0x8548; BYTE $0xc9 // testq %rcx, %rcx + LONG $0xffd9850f; WORD $0xffff // jne LBB12_27, $-39(%rip) + WORD $0x894d; BYTE $0xc2 // movq %r8, %r10 -LBB16_44: - WORD $0x894c; BYTE $0x1e // movq %r11, (%rsi) - LONG $0x00003fe9; BYTE $0x00 // jmp LBB16_50, $63(%rip) +LBB12_32: + WORD $0x2949; BYTE $0xfa // subq %rdi, %r10 + WORD $0x3949; BYTE $0xf2 // cmpq %rsi, %r10 + LONG $0x0024820f; WORD $0x0000 // jb LBB12_5, $36(%rip) + LONG $0x000044e9; BYTE $0x00 // jmp LBB12_34, $68(%rip) -LBB16_45: - WORD $0xf8c5; BYTE $0x77 // vzeroupper - WORD $0xd2f7 // notl %edx - LONG $0xdabc0f44 // bsfl %edx, %r11d - WORD $0x2949; BYTE $0xc3 // subq %rax, %r11 - -LBB16_46: - WORD $0x394d; BYTE $0xc3 // cmpq %r8, %r11 - LONG $0x002a830f; WORD $0x0000 // jae LBB16_50, $42(%rip) +LBB12_19: + WORD $0x894c; BYTE $0x02 // movq %r8, (%rdx) + LONG $0x00003ce9; BYTE $0x00 // jmp LBB12_34, $60(%rip) -LBB16_47: - WORD $0x8b4c; BYTE $0x0f // movq (%rdi), %r9 +LBB12_23: + WORD $0x2949; BYTE $0xfa // subq %rdi, %r10 + WORD $0xd0f7 // notl %eax + WORD $0x9848 // cltq + LONG $0xc0bc0f48 // bsfq %rax, %rax + WORD $0x0149; BYTE $0xc2 // addq %rax, %r10 + WORD $0x3949; BYTE $0xf2 // cmpq %rsi, %r10 + LONG $0x0025830f; WORD $0x0000 // jae LBB12_34, $37(%rip) -LBB16_48: - LONG $0x01438d49 // leaq $1(%r11), %rax - WORD $0x8948; BYTE $0x06 // movq %rax, (%rsi) - LONG $0x04b60f43; BYTE $0x19 // movzbl (%r9,%r11), %eax - WORD $0xbe0f; BYTE $0xc0 // movsbl %al, %eax - BYTE $0x5b // popq %rbx - BYTE $0x5d // popq %rbp - BYTE $0xc3 // retq +LBB12_5: + LONG $0x01428d49 // leaq $1(%r10), %rax + WORD $0x8948; BYTE $0x02 // movq %rax, (%rdx) + LONG $0x17048a42 // movb (%rdi,%r10), %al + WORD $0xbe0f; BYTE $0xc0 // movsbl %al, %eax + BYTE $0x5d // popq %rbp + WORD $0xf8c5; BYTE $0x77 // vzeroupper + BYTE $0xc3 // retq -LBB16_49: - WORD $0xb70f; BYTE $0xc0 // movzwl %ax, %eax - WORD $0xd0f7 // notl %eax - LONG $0xd8bc0f44 // bsfl %eax, %r11d - WORD $0x294d; BYTE $0xd3 // subq %r10, %r11 - WORD $0x394d; BYTE $0xc3 // cmpq %r8, %r11 - LONG $0xffd6820f; WORD $0xffff // jb LBB16_47, $-42(%rip) +LBB12_29: + WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax + WORD $0xf748; BYTE $0xd0 // notq %rax + WORD $0x0149; BYTE $0xc2 // addq %rax, %r10 + WORD $0x3949; BYTE $0xf2 // cmpq %rsi, %r10 + LONG $0xffdb820f; WORD $0xffff // jb LBB12_5, $-37(%rip) -LBB16_50: +LBB12_34: WORD $0xc031 // xorl %eax, %eax WORD $0xbe0f; BYTE $0xc0 // movsbl %al, %eax - BYTE $0x5b // popq %rbx BYTE $0x5d // popq %rbp + WORD $0xf8c5; BYTE $0x77 // vzeroupper BYTE $0xc3 // retq -LBB16_51: - WORD $0x294c; BYTE $0xcb // subq %r9, %rbx - WORD $0x0148; BYTE $0xc3 // addq %rax, %rbx - WORD $0x8949; BYTE $0xdb // movq %rbx, %r11 - WORD $0x394d; BYTE $0xc3 // cmpq %r8, %r11 - LONG $0xffbc820f; WORD $0xffff // jb LBB16_47, $-68(%rip) - LONG $0xffffe1e9; BYTE $0xff // jmp LBB16_50, $-31(%rip) - QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 - + // .p2align 4, 0x90 _vstring: BYTE $0x55 // pushq %rbp WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp @@ -5450,155 +4935,166 @@ _vstring: WORD $0x8b4c; BYTE $0x26 // movq (%rsi), %r12 LONG $0xd8558d48 // leaq $-40(%rbp), %rdx WORD $0x894c; BYTE $0xe6 // movq %r12, %rsi - LONG $0x0000c1e8; BYTE $0x00 // callq _advance_string, $193(%rip) + LONG $0x0000b1e8; BYTE $0x00 // callq _advance_string, $177(%rip) WORD $0x8548; BYTE $0xc0 // testq %rax, %rax - LONG $0x0029880f; WORD $0x0000 // js LBB17_1, $41(%rip) + LONG $0x0027880f; WORD $0x0000 // js LBB13_1, $39(%rip) WORD $0x8948; BYTE $0x03 // movq %rax, (%rbx) LONG $0x1066894d // movq %r12, $16(%r14) - LONG $0x0706c749; WORD $0x0000; BYTE $0x00 // movq $7, (%r14) LONG $0xd84d8b48 // movq $-40(%rbp), %rcx WORD $0x3948; BYTE $0xc1 // cmpq %rax, %rcx LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax LONG $0xc14c0f48 // cmovlq %rcx, %rax LONG $0x18468949 // movq %rax, $24(%r14) - LONG $0x00000ae9; BYTE $0x00 // jmp LBB17_3, $10(%rip) + LONG $0x000007b8; BYTE $0x00 // movl $7, %eax + LONG $0x000007e9; BYTE $0x00 // jmp LBB13_3, $7(%rip) -LBB17_1: +LBB13_1: LONG $0x084f8b49 // movq $8(%r15), %rcx WORD $0x8948; BYTE $0x0b // movq %rcx, (%rbx) - WORD $0x8949; BYTE $0x06 // movq %rax, (%r14) -LBB17_3: - LONG $0x10c48348 // addq $16, %rsp - BYTE $0x5b // popq %rbx - WORD $0x5c41 // popq %r12 - WORD $0x5e41 // popq %r14 - WORD $0x5f41 // popq %r15 - BYTE $0x5d // popq %rbp - BYTE $0xc3 // retq - QUAD $0x0000000000000000; QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .p2align 5, 0x00 +LBB13_3: + WORD $0x8949; BYTE $0x06 // movq %rax, (%r14) + LONG $0x10c48348 // addq $16, %rsp + BYTE $0x5b // popq %rbx + WORD $0x5c41 // popq %r12 + WORD $0x5e41 // popq %r14 + WORD $0x5f41 // popq %r15 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + QUAD $0x0000000000000000; WORD $0x0000 // .p2align 5, 0x00 -LCPI18_0: +LCPI14_0: QUAD $0x2222222222222222; QUAD $0x2222222222222222 // .space 16, '""""""""""""""""' QUAD $0x2222222222222222; QUAD $0x2222222222222222 // .space 16, '""""""""""""""""' -LCPI18_1: +LCPI14_1: QUAD $0x5c5c5c5c5c5c5c5c; QUAD $0x5c5c5c5c5c5c5c5c // .space 16, '\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' QUAD $0x5c5c5c5c5c5c5c5c; QUAD $0x5c5c5c5c5c5c5c5c // .space 16, '\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' -LCPI18_2: - QUAD $0x1f1f1f1f1f1f1f1f; QUAD $0x1f1f1f1f1f1f1f1f // .space 16, '\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f' - QUAD $0x1f1f1f1f1f1f1f1f; QUAD $0x1f1f1f1f1f1f1f1f // .space 16, '\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f' +LCPI14_2: + QUAD $0x2020202020202020; QUAD $0x2020202020202020 // .space 16, ' ' + QUAD $0x2020202020202020; QUAD $0x2020202020202020 // .space 16, ' ' // .p2align 4, 0x90 _advance_string: WORD $0xc1f6; BYTE $0x20 // testb $32, %cl - LONG $0x0005850f; WORD $0x0000 // jne LBB18_2, $5(%rip) - LONG $0x005132e9; BYTE $0x00 // jmp _advance_string_default, $20786(%rip) + LONG $0x0005850f; WORD $0x0000 // jne LBB14_2, $5(%rip) + LONG $0x0053f2e9; BYTE $0x00 // jmp _advance_string_default, $21490(%rip) -LBB18_2: - BYTE $0x55 // pushq %rbp - WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp - WORD $0x5741 // pushq %r15 - WORD $0x5641 // pushq %r14 - WORD $0x5541 // pushq %r13 - WORD $0x5441 // pushq %r12 - BYTE $0x53 // pushq %rbx - LONG $0x087f8b4c // movq $8(%rdi), %r15 - WORD $0x2949; BYTE $0xf7 // subq %rsi, %r15 - LONG $0x03a7840f; WORD $0x0000 // je LBB18_27, $935(%rip) - WORD $0x8b4c; BYTE $0x1f // movq (%rdi), %r11 - LONG $0xff02c748; WORD $0xffff; BYTE $0xff // movq $-1, (%rdx) - LONG $0x40ff8349 // cmpq $64, %r15 - LONG $0x01f4820f; WORD $0x0000 // jb LBB18_28, $500(%rip) - LONG $0xffc0c749; WORD $0xffff; BYTE $0xff // movq $-1, %r8 - WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d - QUAD $0xffffff52056ffdc5 // vmovdqa $-174(%rip), %ymm0 /* LCPI18_0(%rip) */ - QUAD $0xffffff6a0d6ffdc5 // vmovdqa $-150(%rip), %ymm1 /* LCPI18_1(%rip) */ - QUAD $0xffffff82156ffdc5 // vmovdqa $-126(%rip), %ymm2 /* LCPI18_2(%rip) */ - QUAD $0xaaaaaaaaaaaab949; WORD $0xaaaa // movabsq $-6148914691236517206, %r9 - QUAD $0x555555555555ba49; WORD $0x5555 // movabsq $6148914691236517205, %r10 - QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 - -LBB18_5: - LONG $0x6f7ec1c4; WORD $0x331c // vmovdqu (%r11,%rsi), %ymm3 - LONG $0x6f7ec1c4; WORD $0x3364; BYTE $0x20 // vmovdqu $32(%r11,%rsi), %ymm4 - LONG $0xe874e5c5 // vpcmpeqb %ymm0, %ymm3, %ymm5 - LONG $0xe5d77dc5 // vpmovmskb %ymm5, %r12d - LONG $0xe874ddc5 // vpcmpeqb %ymm0, %ymm4, %ymm5 - LONG $0xcdd7fdc5 // vpmovmskb %ymm5, %ecx - LONG $0xe974e5c5 // vpcmpeqb %ymm1, %ymm3, %ymm5 - LONG $0xc5d7fdc5 // vpmovmskb %ymm5, %eax - LONG $0xe974ddc5 // vpcmpeqb %ymm1, %ymm4, %ymm5 - LONG $0xddd7fdc5 // vpmovmskb %ymm5, %ebx - LONG $0xeadaddc5 // vpminub %ymm2, %ymm4, %ymm5 - LONG $0xe574ddc5 // vpcmpeqb %ymm5, %ymm4, %ymm4 - LONG $0xfcd7fdc5 // vpmovmskb %ymm4, %edi - LONG $0x20e1c148 // shlq $32, %rcx - WORD $0x0949; BYTE $0xcc // orq %rcx, %r12 - LONG $0x20e3c148 // shlq $32, %rbx - LONG $0x20e7c148 // shlq $32, %rdi - WORD $0x0948; BYTE $0xd8 // orq %rbx, %rax - LONG $0x0044850f; WORD $0x0000 // jne LBB18_11, $68(%rip) - WORD $0x854d; BYTE $0xf6 // testq %r14, %r14 - LONG $0x004f850f; WORD $0x0000 // jne LBB18_13, $79(%rip) +LBB14_2: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5741 // pushq %r15 + WORD $0x5641 // pushq %r14 + WORD $0x5541 // pushq %r13 + WORD $0x5441 // pushq %r12 + BYTE $0x53 // pushq %rbx + BYTE $0x50 // pushq %rax + LONG $0x087f8b4c // movq $8(%rdi), %r15 + WORD $0x2949; BYTE $0xf7 // subq %rsi, %r15 + LONG $0x03d6840f; WORD $0x0000 // je LBB14_21, $982(%rip) + WORD $0x8b4c; BYTE $0x1f // movq (%rdi), %r11 + WORD $0x014c; BYTE $0xde // addq %r11, %rsi + LONG $0xff02c748; WORD $0xffff; BYTE $0xff // movq $-1, (%rdx) + LONG $0x40ff8349 // cmpq $64, %r15 + LONG $0x01b4820f; WORD $0x0000 // jb LBB14_22, $436(%rip) + QUAD $0xffffffffd045c748 // movq $-1, $-48(%rbp) WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d + QUAD $0xffffff4d056ffdc5 // vmovdqa $-179(%rip), %ymm0 /* LCPI14_0(%rip) */ + QUAD $0xffffff650d6ffdc5 // vmovdqa $-155(%rip), %ymm1 /* LCPI14_1(%rip) */ + QUAD $0xffffff7d156ffdc5 // vmovdqa $-131(%rip), %ymm2 /* LCPI14_2(%rip) */ + LONG $0xdb76e5c5 // vpcmpeqd %ymm3, %ymm3, %ymm3 + QUAD $0xaaaaaaaaaaaab949; WORD $0xaaaa // movabsq $-6148914691236517206, %r9 + QUAD $0x555555555555ba49; WORD $0x5555 // movabsq $6148914691236517205, %r10 + LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 -LBB18_8: - LONG $0xe2dae5c5 // vpminub %ymm2, %ymm3, %ymm4 - LONG $0xdc74e5c5 // vpcmpeqb %ymm4, %ymm3, %ymm3 - LONG $0xc3d7fdc5 // vpmovmskb %ymm3, %eax - WORD $0x0948; BYTE $0xc7 // orq %rax, %rdi - WORD $0x854d; BYTE $0xe4 // testq %r12, %r12 - LONG $0x006e850f; WORD $0x0000 // jne LBB18_14, $110(%rip) - WORD $0x8548; BYTE $0xff // testq %rdi, %rdi - LONG $0x00b3850f; WORD $0x0000 // jne LBB18_20, $179(%rip) - LONG $0xc0c78349 // addq $-64, %r15 +LBB14_5: + LONG $0x266ffec5 // vmovdqu (%rsi), %ymm4 + LONG $0x6e6ffec5; BYTE $0x20 // vmovdqu $32(%rsi), %ymm5 + LONG $0xf074ddc5 // vpcmpeqb %ymm0, %ymm4, %ymm6 + LONG $0xeed77dc5 // vpmovmskb %ymm6, %r13d + LONG $0xf074d5c5 // vpcmpeqb %ymm0, %ymm5, %ymm6 + LONG $0xc6d7fdc5 // vpmovmskb %ymm6, %eax + LONG $0xf174ddc5 // vpcmpeqb %ymm1, %ymm4, %ymm6 + LONG $0xced7fdc5 // vpmovmskb %ymm6, %ecx + LONG $0xf174d5c5 // vpcmpeqb %ymm1, %ymm5, %ymm6 + LONG $0xfed7fdc5 // vpmovmskb %ymm6, %edi + LONG $0xf464edc5 // vpcmpgtb %ymm4, %ymm2, %ymm6 + LONG $0xe364ddc5 // vpcmpgtb %ymm3, %ymm4, %ymm4 + LONG $0xe4dbcdc5 // vpand %ymm4, %ymm6, %ymm4 + LONG $0xe4d77dc5 // vpmovmskb %ymm4, %r12d + LONG $0xe564edc5 // vpcmpgtb %ymm5, %ymm2, %ymm4 + LONG $0xeb64d5c5 // vpcmpgtb %ymm3, %ymm5, %ymm5 + LONG $0xe5dbddc5 // vpand %ymm5, %ymm4, %ymm4 + LONG $0xdcd7fdc5 // vpmovmskb %ymm4, %ebx + LONG $0x20e0c148 // shlq $32, %rax + WORD $0x0949; BYTE $0xc5 // orq %rax, %r13 + LONG $0x20e7c148 // shlq $32, %rdi + LONG $0x20e3c148 // shlq $32, %rbx + WORD $0x0948; BYTE $0xf9 // orq %rdi, %rcx + LONG $0x0038850f; WORD $0x0000 // jne LBB14_10, $56(%rip) + WORD $0x854d; BYTE $0xf6 // testq %r14, %r14 + LONG $0x004e850f; WORD $0x0000 // jne LBB14_12, $78(%rip) + WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d + WORD $0x094c; BYTE $0xe3 // orq %r12, %rbx + WORD $0x854d; BYTE $0xed // testq %r13, %r13 + LONG $0x0080850f; WORD $0x0000 // jne LBB14_13, $128(%rip) + +LBB14_8: + WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx + LONG $0x00ce850f; WORD $0x0000 // jne LBB14_19, $206(%rip) LONG $0x40c68348 // addq $64, %rsi + LONG $0xc0c78349 // addq $-64, %r15 LONG $0x3fff8349 // cmpq $63, %r15 - LONG $0xff70870f; WORD $0xffff // ja LBB18_5, $-144(%rip) - LONG $0x0000bce9; BYTE $0x00 // jmp LBB18_22, $188(%rip) - -LBB18_11: - LONG $0xfff88349 // cmpq $-1, %r8 - LONG $0x000a850f; WORD $0x0000 // jne LBB18_13, $10(%rip) - LONG $0xc0bc0f4c // bsfq %rax, %r8 - WORD $0x0149; BYTE $0xf0 // addq %rsi, %r8 - WORD $0x894c; BYTE $0x02 // movq %r8, (%rdx) + LONG $0xff6c870f; WORD $0xffff // ja LBB14_5, $-148(%rip) + LONG $0x0000e6e9; BYTE $0x00 // jmp LBB14_23, $230(%rip) + +LBB14_10: + LONG $0xd07d8348; BYTE $0xff // cmpq $-1, $-48(%rbp) + LONG $0x0014850f; WORD $0x0000 // jne LBB14_12, $20(%rip) + WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax + WORD $0x294c; BYTE $0xd8 // subq %r11, %rax + LONG $0xf9bc0f48 // bsfq %rcx, %rdi + WORD $0x0148; BYTE $0xc7 // addq %rax, %rdi + LONG $0xd07d8948 // movq %rdi, $-48(%rbp) + WORD $0x8948; BYTE $0x3a // movq %rdi, (%rdx) -LBB18_13: - WORD $0x894c; BYTE $0xf1 // movq %r14, %rcx - WORD $0xf748; BYTE $0xd1 // notq %rcx - WORD $0x2148; BYTE $0xc1 // andq %rax, %rcx - LONG $0x092c8d4c // leaq (%rcx,%rcx), %r13 - WORD $0x094d; BYTE $0xf5 // orq %r14, %r13 - WORD $0x894c; BYTE $0xeb // movq %r13, %rbx - WORD $0xf748; BYTE $0xd3 // notq %rbx - WORD $0x2148; BYTE $0xc3 // andq %rax, %rbx - WORD $0x214c; BYTE $0xcb // andq %r9, %rbx - WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d - WORD $0x0148; BYTE $0xcb // addq %rcx, %rbx - LONG $0xc6920f41 // setb %r14b - WORD $0x0148; BYTE $0xdb // addq %rbx, %rbx - WORD $0x314c; BYTE $0xd3 // xorq %r10, %rbx - WORD $0x214c; BYTE $0xeb // andq %r13, %rbx - WORD $0xf748; BYTE $0xd3 // notq %rbx - WORD $0x2149; BYTE $0xdc // andq %rbx, %r12 - LONG $0xffff7ae9; BYTE $0xff // jmp LBB18_8, $-134(%rip) +LBB14_12: + WORD $0x894c; BYTE $0xf0 // movq %r14, %rax + WORD $0xf748; BYTE $0xd0 // notq %rax + WORD $0x2148; BYTE $0xc8 // andq %rcx, %rax + LONG $0x00048d4c // leaq (%rax,%rax), %r8 + WORD $0x094d; BYTE $0xf0 // orq %r14, %r8 + WORD $0x894c; BYTE $0xc7 // movq %r8, %rdi + WORD $0xf748; BYTE $0xd7 // notq %rdi + WORD $0x2148; BYTE $0xcf // andq %rcx, %rdi + WORD $0x214c; BYTE $0xcf // andq %r9, %rdi + WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d + WORD $0x0148; BYTE $0xc7 // addq %rax, %rdi + LONG $0xc6920f41 // setb %r14b + WORD $0x0148; BYTE $0xff // addq %rdi, %rdi + WORD $0x314c; BYTE $0xd7 // xorq %r10, %rdi + WORD $0x214c; BYTE $0xc7 // andq %r8, %rdi + WORD $0xf748; BYTE $0xd7 // notq %rdi + WORD $0x2149; BYTE $0xfd // andq %rdi, %r13 + WORD $0x094c; BYTE $0xe3 // orq %r12, %rbx + WORD $0x854d; BYTE $0xed // testq %r13, %r13 + LONG $0xff80840f; WORD $0xffff // je LBB14_8, $-128(%rip) -LBB18_14: - LONG $0xc4bc0f49 // bsfq %r12, %rax - WORD $0x8548; BYTE $0xff // testq %rdi, %rdi - LONG $0x0021840f; WORD $0x0000 // je LBB18_18, $33(%rip) - LONG $0xcfbc0f48 // bsfq %rdi, %rcx +LBB14_13: + LONG $0xc5bc0f49 // bsfq %r13, %rax + WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx + LONG $0x0027840f; WORD $0x0000 // je LBB14_17, $39(%rip) + LONG $0xcbbc0f48 // bsfq %rbx, %rcx + WORD $0x294c; BYTE $0xde // subq %r11, %rsi WORD $0x3948; BYTE $0xc1 // cmpq %rax, %rcx - LONG $0x0022820f; WORD $0x0000 // jb LBB18_19, $34(%rip) + LONG $0x0028820f; WORD $0x0000 // jb LBB14_18, $40(%rip) -LBB18_16: - WORD $0x0148; BYTE $0xf0 // addq %rsi, %rax - WORD $0xff48; BYTE $0xc0 // incq %rax +LBB14_15: + LONG $0x06448d48; BYTE $0x01 // leaq $1(%rsi,%rax), %rax -LBB18_17: +LBB14_16: + LONG $0x08c48348 // addq $8, %rsp BYTE $0x5b // popq %rbx WORD $0x5c41 // popq %r12 WORD $0x5d41 // popq %r13 @@ -5608,212 +5104,211 @@ LBB18_17: WORD $0xf8c5; BYTE $0x77 // vzeroupper BYTE $0xc3 // retq -LBB18_18: +LBB14_17: LONG $0x000040b9; BYTE $0x00 // movl $64, %ecx + WORD $0x294c; BYTE $0xde // subq %r11, %rsi WORD $0x3948; BYTE $0xc1 // cmpq %rax, %rcx - LONG $0xffde830f; WORD $0xffff // jae LBB18_16, $-34(%rip) + LONG $0xffd8830f; WORD $0xffff // jae LBB14_15, $-40(%rip) -LBB18_19: +LBB14_18: WORD $0x0148; BYTE $0xf1 // addq %rsi, %rcx WORD $0x8948; BYTE $0x0a // movq %rcx, (%rdx) LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq $-2, %rax - LONG $0xffffd2e9; BYTE $0xff // jmp LBB18_17, $-46(%rip) + LONG $0xffffcbe9; BYTE $0xff // jmp LBB14_16, $-53(%rip) -LBB18_20: +LBB14_19: LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq $-2, %rax - LONG $0xfff88349 // cmpq $-1, %r8 - LONG $0xffc1850f; WORD $0xffff // jne LBB18_17, $-63(%rip) - LONG $0xcfbc0f48 // bsfq %rdi, %rcx - WORD $0x0148; BYTE $0xf1 // addq %rsi, %rcx - WORD $0x8948; BYTE $0x0a // movq %rcx, (%rdx) - LONG $0xffffb2e9; BYTE $0xff // jmp LBB18_17, $-78(%rip) + LONG $0xd07d8348; BYTE $0xff // cmpq $-1, $-48(%rbp) + LONG $0xffb9850f; WORD $0xffff // jne LBB14_16, $-71(%rip) + LONG $0xcbbc0f48 // bsfq %rbx, %rcx + WORD $0x294c; BYTE $0xde // subq %r11, %rsi + WORD $0x0148; BYTE $0xce // addq %rcx, %rsi + WORD $0x8948; BYTE $0x32 // movq %rsi, (%rdx) + LONG $0xffffa7e9; BYTE $0xff // jmp LBB14_16, $-89(%rip) -LBB18_22: - WORD $0x014c; BYTE $0xde // addq %r11, %rsi - LONG $0x20ff8349 // cmpq $32, %r15 - LONG $0x0107820f; WORD $0x0000 // jb LBB18_38, $263(%rip) +LBB14_22: + QUAD $0xffffffffd045c748 // movq $-1, $-48(%rbp) + WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d -LBB18_23: +LBB14_23: + LONG $0x20ff8349 // cmpq $32, %r15 + LONG $0x009e820f; WORD $0x0000 // jb LBB14_33, $158(%rip) LONG $0x066ffec5 // vmovdqu (%rsi), %ymm0 - QUAD $0xfffffdb60d74fdc5 // vpcmpeqb $-586(%rip), %ymm0, %ymm1 /* LCPI18_0(%rip) */ - LONG $0xc9d77dc5 // vpmovmskb %ymm1, %r9d - QUAD $0xfffffdca0d74fdc5 // vpcmpeqb $-566(%rip), %ymm0, %ymm1 /* LCPI18_1(%rip) */ + QUAD $0xfffffd8b0d74fdc5 // vpcmpeqb $-629(%rip), %ymm0, %ymm1 /* LCPI14_0(%rip) */ + LONG $0xf9d7fdc5 // vpmovmskb %ymm1, %edi + QUAD $0xfffffd9f0d74fdc5 // vpcmpeqb $-609(%rip), %ymm0, %ymm1 /* LCPI14_1(%rip) */ LONG $0xc1d7fdc5 // vpmovmskb %ymm1, %eax - QUAD $0xfffffdde0ddafdc5 // vpminub $-546(%rip), %ymm0, %ymm1 /* LCPI18_2(%rip) */ - LONG $0xc174fdc5 // vpcmpeqb %ymm1, %ymm0, %ymm0 + QUAD $0xfffffdb30d6ffdc5 // vmovdqa $-589(%rip), %ymm1 /* LCPI14_2(%rip) */ + LONG $0xc864f5c5 // vpcmpgtb %ymm0, %ymm1, %ymm1 + LONG $0xd276edc5 // vpcmpeqd %ymm2, %ymm2, %ymm2 + LONG $0xc264fdc5 // vpcmpgtb %ymm2, %ymm0, %ymm0 + LONG $0xc0dbf5c5 // vpand %ymm0, %ymm1, %ymm0 + LONG $0xc8d77dc5 // vpmovmskb %ymm0, %r9d WORD $0xc085 // testl %eax, %eax - LONG $0x003e850f; WORD $0x0000 // jne LBB18_29, $62(%rip) + LONG $0x00f3850f; WORD $0x0000 // jne LBB14_44, $243(%rip) WORD $0x854d; BYTE $0xf6 // testq %r14, %r14 - LONG $0x004f850f; WORD $0x0000 // jne LBB18_31, $79(%rip) - WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d - LONG $0xd8d7fdc5 // vpmovmskb %ymm0, %ebx - WORD $0x854d; BYTE $0xc9 // testq %r9, %r9 - LONG $0x007c840f; WORD $0x0000 // je LBB18_32, $124(%rip) - -LBB18_26: - LONG $0xd1bc0f4d // bsfq %r9, %r10 - LONG $0x000079e9; BYTE $0x00 // jmp LBB18_33, $121(%rip) - -LBB18_28: - WORD $0x014c; BYTE $0xde // addq %r11, %rsi - LONG $0xffc0c749; WORD $0xffff; BYTE $0xff // movq $-1, %r8 - WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d - LONG $0x20ff8349 // cmpq $32, %r15 - LONG $0xff97830f; WORD $0xffff // jae LBB18_23, $-105(%rip) - LONG $0x000099e9; BYTE $0x00 // jmp LBB18_38, $153(%rip) - -LBB18_29: - LONG $0xfff88349 // cmpq $-1, %r8 - LONG $0x0010850f; WORD $0x0000 // jne LBB18_31, $16(%rip) - WORD $0x8948; BYTE $0xf1 // movq %rsi, %rcx - WORD $0x294c; BYTE $0xd9 // subq %r11, %rcx - LONG $0xc0bc0f4c // bsfq %rax, %r8 - WORD $0x0149; BYTE $0xc8 // addq %rcx, %r8 - WORD $0x894c; BYTE $0x02 // movq %r8, (%rdx) - -LBB18_31: - WORD $0x8944; BYTE $0xf1 // movl %r14d, %ecx - WORD $0xd1f7 // notl %ecx - WORD $0xc121 // andl %eax, %ecx - WORD $0x3c8d; BYTE $0x09 // leal (%rcx,%rcx), %edi - LONG $0x4e1c8d41 // leal (%r14,%rcx,2), %ebx - WORD $0xd7f7 // notl %edi - WORD $0xc721 // andl %eax, %edi - LONG $0xaaaae781; WORD $0xaaaa // andl $-1431655766, %edi + LONG $0x0109850f; WORD $0x0000 // jne LBB14_46, $265(%rip) WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d - WORD $0xcf01 // addl %ecx, %edi - LONG $0xc6920f41 // setb %r14b - WORD $0xff01 // addl %edi, %edi - LONG $0x5555f781; WORD $0x5555 // xorl $1431655765, %edi - WORD $0xdf21 // andl %ebx, %edi - WORD $0xd7f7 // notl %edi - WORD $0x2141; BYTE $0xf9 // andl %edi, %r9d - LONG $0xd8d7fdc5 // vpmovmskb %ymm0, %ebx - WORD $0x854d; BYTE $0xc9 // testq %r9, %r9 - LONG $0xff84850f; WORD $0xffff // jne LBB18_26, $-124(%rip) + LONG $0x000040b8; BYTE $0x00 // movl $64, %eax + LONG $0x000040b9; BYTE $0x00 // movl $64, %ecx + WORD $0x8548; BYTE $0xff // testq %rdi, %rdi + LONG $0x0004840f; WORD $0x0000 // je LBB14_28, $4(%rip) -LBB18_32: - LONG $0x0040ba41; WORD $0x0000 // movl $64, %r10d +LBB14_27: + LONG $0xcfbc0f48 // bsfq %rdi, %rcx -LBB18_33: - WORD $0xbc0f; BYTE $0xc3 // bsfl %ebx, %eax - LONG $0x000040bf; BYTE $0x00 // movl $64, %edi - WORD $0x450f; BYTE $0xf8 // cmovnel %eax, %edi - WORD $0x854d; BYTE $0xc9 // testq %r9, %r9 - LONG $0x0018840f; WORD $0x0000 // je LBB18_36, $24(%rip) +LBB14_28: + LONG $0xd9bc0f49 // bsfq %r9, %rbx + WORD $0x8545; BYTE $0xc9 // testl %r9d, %r9d + LONG $0xc3450f48 // cmovneq %rbx, %rax + WORD $0x8548; BYTE $0xff // testq %rdi, %rdi + LONG $0x0016840f; WORD $0x0000 // je LBB14_31, $22(%rip) WORD $0x294c; BYTE $0xde // subq %r11, %rsi - WORD $0x3949; BYTE $0xfa // cmpq %rdi, %r10 - LONG $0x00ad870f; WORD $0x0000 // ja LBB18_49, $173(%rip) - LONG $0x16048d4a // leaq (%rsi,%r10), %rax - WORD $0xff48; BYTE $0xc0 // incq %rax - LONG $0xfffeaee9; BYTE $0xff // jmp LBB18_17, $-338(%rip) + WORD $0x3948; BYTE $0xc8 // cmpq %rcx, %rax + LONG $0x0117820f; WORD $0x0000 // jb LBB14_47, $279(%rip) + LONG $0x0e448d48; BYTE $0x01 // leaq $1(%rsi,%rcx), %rax + LONG $0xffff05e9; BYTE $0xff // jmp LBB14_16, $-251(%rip) -LBB18_36: - WORD $0xdb85 // testl %ebx, %ebx - LONG $0x00a1850f; WORD $0x0000 // jne LBB18_50, $161(%rip) +LBB14_31: + WORD $0x8545; BYTE $0xc9 // testl %r9d, %r9d + LONG $0x0116850f; WORD $0x0000 // jne LBB14_48, $278(%rip) LONG $0x20c68348 // addq $32, %rsi LONG $0xe0c78349 // addq $-32, %r15 -LBB18_38: +LBB14_33: WORD $0x854d; BYTE $0xf6 // testq %r14, %r14 - LONG $0x00a7850f; WORD $0x0000 // jne LBB18_51, $167(%rip) + LONG $0x0110850f; WORD $0x0000 // jne LBB14_49, $272(%rip) LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax WORD $0x854d; BYTE $0xff // testq %r15, %r15 - LONG $0xfe85840f; WORD $0xffff // je LBB18_17, $-379(%rip) - -LBB18_40: - WORD $0xb60f; BYTE $0x3e // movzbl (%rsi), %edi - WORD $0xff83; BYTE $0x22 // cmpl $34, %edi - LONG $0x005e840f; WORD $0x0000 // je LBB18_48, $94(%rip) - WORD $0xff83; BYTE $0x5c // cmpl $92, %edi - LONG $0x0027840f; WORD $0x0000 // je LBB18_45, $39(%rip) - LONG $0x1fff8040 // cmpb $31, %dil - LONG $0x00be860f; WORD $0x0000 // jbe LBB18_55, $190(%rip) - LONG $0xffc7c748; WORD $0xffff; BYTE $0xff // movq $-1, %rdi - LONG $0x000001bb; BYTE $0x00 // movl $1, %ebx + LONG $0xfedb840f; WORD $0xffff // je LBB14_16, $-293(%rip) -LBB18_44: - WORD $0x0148; BYTE $0xde // addq %rbx, %rsi - WORD $0x0149; BYTE $0xff // addq %rdi, %r15 - LONG $0xffc9850f; WORD $0xffff // jne LBB18_40, $-55(%rip) - LONG $0xfffe49e9; BYTE $0xff // jmp LBB18_17, $-439(%rip) +LBB14_35: + WORD $0xb60f; BYTE $0x0e // movzbl (%rsi), %ecx + WORD $0xf980; BYTE $0x22 // cmpb $34, %cl + LONG $0x0062840f; WORD $0x0000 // je LBB14_43, $98(%rip) + WORD $0xf980; BYTE $0x5c // cmpb $92, %cl + LONG $0x0026840f; WORD $0x0000 // je LBB14_40, $38(%rip) + WORD $0xf980; BYTE $0x1f // cmpb $31, %cl + LONG $0x012d860f; WORD $0x0000 // jbe LBB14_53, $301(%rip) + LONG $0xffc1c748; WORD $0xffff; BYTE $0xff // movq $-1, %rcx + LONG $0x000001bf; BYTE $0x00 // movl $1, %edi -LBB18_45: +LBB14_39: + WORD $0x0148; BYTE $0xfe // addq %rdi, %rsi + WORD $0x0149; BYTE $0xcf // addq %rcx, %r15 + LONG $0xffca850f; WORD $0xffff // jne LBB14_35, $-54(%rip) + LONG $0xfffea0e9; BYTE $0xff // jmp LBB14_16, $-352(%rip) + +LBB14_40: LONG $0x01ff8349 // cmpq $1, %r15 - LONG $0xfe3f840f; WORD $0xffff // je LBB18_17, $-449(%rip) - LONG $0xfec7c748; WORD $0xffff; BYTE $0xff // movq $-2, %rdi - LONG $0x000002bb; BYTE $0x00 // movl $2, %ebx - LONG $0xfff88349 // cmpq $-1, %r8 - LONG $0xffcf850f; WORD $0xffff // jne LBB18_44, $-49(%rip) - WORD $0x8949; BYTE $0xf0 // movq %rsi, %r8 - WORD $0x294d; BYTE $0xd8 // subq %r11, %r8 - WORD $0x894c; BYTE $0x02 // movq %r8, (%rdx) - LONG $0xffffc1e9; BYTE $0xff // jmp LBB18_44, $-63(%rip) - -LBB18_48: + LONG $0xfe96840f; WORD $0xffff // je LBB14_16, $-362(%rip) + LONG $0xfec1c748; WORD $0xffff; BYTE $0xff // movq $-2, %rcx + LONG $0x000002bf; BYTE $0x00 // movl $2, %edi + LONG $0xd07d8348; BYTE $0xff // cmpq $-1, $-48(%rbp) + LONG $0xffce850f; WORD $0xffff // jne LBB14_39, $-50(%rip) + WORD $0x8948; BYTE $0xf3 // movq %rsi, %rbx + WORD $0x294c; BYTE $0xdb // subq %r11, %rbx + LONG $0xd05d8948 // movq %rbx, $-48(%rbp) + WORD $0x8948; BYTE $0x1a // movq %rbx, (%rdx) + LONG $0xffffbce9; BYTE $0xff // jmp LBB14_39, $-68(%rip) + +LBB14_43: WORD $0x294c; BYTE $0xde // subq %r11, %rsi WORD $0xff48; BYTE $0xc6 // incq %rsi WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax - LONG $0xfffe0de9; BYTE $0xff // jmp LBB18_17, $-499(%rip) + LONG $0xfffe5fe9; BYTE $0xff // jmp LBB14_16, $-417(%rip) + +LBB14_44: + LONG $0xd07d8348; BYTE $0xff // cmpq $-1, $-48(%rbp) + LONG $0x0014850f; WORD $0x0000 // jne LBB14_46, $20(%rip) + WORD $0x8948; BYTE $0xf1 // movq %rsi, %rcx + WORD $0x294c; BYTE $0xd9 // subq %r11, %rcx + LONG $0xd8bc0f48 // bsfq %rax, %rbx + WORD $0x0148; BYTE $0xcb // addq %rcx, %rbx + LONG $0xd05d8948 // movq %rbx, $-48(%rbp) + WORD $0x8948; BYTE $0x1a // movq %rbx, (%rdx) -LBB18_49: - WORD $0x0148; BYTE $0xfe // addq %rdi, %rsi - LONG $0x000060e9; BYTE $0x00 // jmp LBB18_56, $96(%rip) +LBB14_46: + WORD $0x8944; BYTE $0xf1 // movl %r14d, %ecx + WORD $0xd1f7 // notl %ecx + WORD $0xc121 // andl %eax, %ecx + WORD $0x1c8d; BYTE $0x09 // leal (%rcx,%rcx), %ebx + LONG $0x4e048d45 // leal (%r14,%rcx,2), %r8d + WORD $0xd3f7 // notl %ebx + WORD $0xc321 // andl %eax, %ebx + LONG $0xaaaae381; WORD $0xaaaa // andl $-1431655766, %ebx + WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d + WORD $0xcb01 // addl %ecx, %ebx + LONG $0xc6920f41 // setb %r14b + WORD $0xdb01 // addl %ebx, %ebx + LONG $0x5555f381; WORD $0x5555 // xorl $1431655765, %ebx + WORD $0x2144; BYTE $0xc3 // andl %r8d, %ebx + WORD $0xd3f7 // notl %ebx + WORD $0xdf21 // andl %ebx, %edi + LONG $0x000040b8; BYTE $0x00 // movl $64, %eax + LONG $0x000040b9; BYTE $0x00 // movl $64, %ecx + WORD $0x8548; BYTE $0xff // testq %rdi, %rdi + LONG $0xfeca850f; WORD $0xffff // jne LBB14_27, $-310(%rip) + LONG $0xfffec9e9; BYTE $0xff // jmp LBB14_28, $-311(%rip) -LBB18_50: - WORD $0x294c; BYTE $0xde // subq %r11, %rsi - WORD $0xc089 // movl %eax, %eax +LBB14_47: WORD $0x0148; BYTE $0xf0 // addq %rsi, %rax WORD $0x8948; BYTE $0x02 // movq %rax, (%rdx) LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq $-2, %rax - LONG $0xfffdeee9; BYTE $0xff // jmp LBB18_17, $-530(%rip) + LONG $0xfffde6e9; BYTE $0xff // jmp LBB14_16, $-538(%rip) + +LBB14_48: + WORD $0x294c; BYTE $0xde // subq %r11, %rsi + WORD $0x0148; BYTE $0xde // addq %rbx, %rsi + LONG $0x00004ee9; BYTE $0x00 // jmp LBB14_54, $78(%rip) -LBB18_51: +LBB14_49: WORD $0x854d; BYTE $0xff // testq %r15, %r15 - LONG $0x0031840f; WORD $0x0000 // je LBB18_27, $49(%rip) - LONG $0xfff88349 // cmpq $-1, %r8 - LONG $0x000c850f; WORD $0x0000 // jne LBB18_54, $12(%rip) - WORD $0x894d; BYTE $0xd8 // movq %r11, %r8 - WORD $0xf749; BYTE $0xd0 // notq %r8 - WORD $0x0149; BYTE $0xf0 // addq %rsi, %r8 - WORD $0x894c; BYTE $0x02 // movq %r8, (%rdx) + LONG $0x0036840f; WORD $0x0000 // je LBB14_21, $54(%rip) + LONG $0xd07d8348; BYTE $0xff // cmpq $-1, $-48(%rbp) + LONG $0x0010850f; WORD $0x0000 // jne LBB14_52, $16(%rip) + WORD $0x894c; BYTE $0xd8 // movq %r11, %rax + WORD $0xf748; BYTE $0xd0 // notq %rax + WORD $0x0148; BYTE $0xf0 // addq %rsi, %rax + LONG $0xd0458948 // movq %rax, $-48(%rbp) + WORD $0x8948; BYTE $0x02 // movq %rax, (%rdx) -LBB18_54: +LBB14_52: WORD $0xff48; BYTE $0xc6 // incq %rsi WORD $0xff49; BYTE $0xcf // decq %r15 LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax WORD $0x854d; BYTE $0xff // testq %r15, %r15 - LONG $0xff34850f; WORD $0xffff // jne LBB18_40, $-204(%rip) - LONG $0xfffdb4e9; BYTE $0xff // jmp LBB18_17, $-588(%rip) + LONG $0xfec6850f; WORD $0xffff // jne LBB14_35, $-314(%rip) + LONG $0xfffd9ce9; BYTE $0xff // jmp LBB14_16, $-612(%rip) -LBB18_27: +LBB14_21: LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax - LONG $0xfffda8e9; BYTE $0xff // jmp LBB18_17, $-600(%rip) + LONG $0xfffd90e9; BYTE $0xff // jmp LBB14_16, $-624(%rip) -LBB18_55: +LBB14_53: WORD $0x294c; BYTE $0xde // subq %r11, %rsi -LBB18_56: +LBB14_54: WORD $0x8948; BYTE $0x32 // movq %rsi, (%rdx) LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq $-2, %rax - LONG $0xfffd96e9; BYTE $0xff // jmp LBB18_17, $-618(%rip) + LONG $0xfffd7ee9; BYTE $0xff // jmp LBB14_16, $-642(%rip) WORD $0x0000; BYTE $0x00 // .p2align 4, 0x00 -LCPI19_0: +LCPI15_0: LONG $0x43300000 // .long 1127219200 LONG $0x45300000 // .long 1160773632 LONG $0x00000000 // .long 0 LONG $0x00000000 // .long 0 -LCPI19_1: +LCPI15_1: QUAD $0x4330000000000000 // .quad 0x4330000000000000 QUAD $0x4530000000000000 // .quad 0x4530000000000000 // .p2align 3, 0x00 -LCPI19_2: +LCPI15_2: QUAD $0x430c6bf526340000 // .quad 0x430c6bf526340000 -LCPI19_3: +LCPI15_3: QUAD $0xc30c6bf526340000 // .quad 0xc30c6bf526340000 // .p2align 4, 0x90 @@ -5826,12 +5321,12 @@ _vnumber: WORD $0x5441 // pushq %r12 BYTE $0x53 // pushq %rbx LONG $0x38ec8348 // subq $56, %rsp - WORD $0x8948; BYTE $0xd3 // movq %rdx, %rbx - WORD $0x8949; BYTE $0xf6 // movq %rsi, %r14 + WORD $0x8949; BYTE $0xd6 // movq %rdx, %r14 + QUAD $0x00000000c845c748 // movq $0, $-56(%rbp) WORD $0x8b48; BYTE $0x06 // movq (%rsi), %rax WORD $0x8b4c; BYTE $0x3f // movq (%rdi), %r15 LONG $0x086f8b4c // movq $8(%rdi), %r13 - LONG $0x20528b4c // movq $32(%rdx), %r10 + LONG $0x205a8b48 // movq $32(%rdx), %rbx LONG $0x285a8b4c // movq $40(%rdx), %r11 LONG $0x0902c748; WORD $0x0000; BYTE $0x00 // movq $9, (%rdx) LONG $0xc057f9c5 // vxorpd %xmm0, %xmm0, %xmm0 @@ -5839,436 +5334,465 @@ _vnumber: WORD $0x8b48; BYTE $0x0e // movq (%rsi), %rcx LONG $0x184a8948 // movq %rcx, $24(%rdx) WORD $0x394c; BYTE $0xe8 // cmpq %r13, %rax - LONG $0x02c9830f; WORD $0x0000 // jae LBB19_51, $713(%rip) - LONG $0x0cb60f41; BYTE $0x07 // movzbl (%r15,%rax), %ecx - LONG $0x000001bf; BYTE $0x00 // movl $1, %edi - WORD $0xf980; BYTE $0x2d // cmpb $45, %cl - LONG $0x0016850f; WORD $0x0000 // jne LBB19_4, $22(%rip) + LONG $0x0045830f; WORD $0x0000 // jae LBB15_6, $69(%rip) + LONG $0x073c8a41 // movb (%r15,%rax), %dil + LONG $0x0001ba41; WORD $0x0000 // movl $1, %r10d + LONG $0x2dff8040 // cmpb $45, %dil + LONG $0x0016850f; WORD $0x0000 // jne LBB15_4, $22(%rip) WORD $0xff48; BYTE $0xc0 // incq %rax WORD $0x394c; BYTE $0xe8 // cmpq %r13, %rax - LONG $0x02aa830f; WORD $0x0000 // jae LBB19_51, $682(%rip) - LONG $0x0cb60f41; BYTE $0x07 // movzbl (%r15,%rax), %ecx - LONG $0xffffffbf; BYTE $0xff // movl $-1, %edi + LONG $0x0025830f; WORD $0x0000 // jae LBB15_6, $37(%rip) + LONG $0x073c8a41 // movb (%r15,%rax), %dil + LONG $0xffffba41; WORD $0xffff // movl $-1, %r10d -LBB19_4: - WORD $0x518d; BYTE $0xc6 // leal $-58(%rcx), %edx - WORD $0xfa80; BYTE $0xf5 // cmpb $-11, %dl - LONG $0x000f870f; WORD $0x0000 // ja LBB19_6, $15(%rip) +LBB15_4: + WORD $0x4f8d; BYTE $0xd0 // leal $-48(%rdi), %ecx + WORD $0xf980; BYTE $0x0a // cmpb $10, %cl + LONG $0x0028820f; WORD $0x0000 // jb LBB15_9, $40(%rip) + WORD $0x8948; BYTE $0x06 // movq %rax, (%rsi) + LONG $0xfe06c749; WORD $0xffff; BYTE $0xff // movq $-2, (%r14) + LONG $0x00000ae9; BYTE $0x00 // jmp LBB15_8, $10(%rip) -LBB19_5: - WORD $0x8949; BYTE $0x06 // movq %rax, (%r14) - LONG $0xfe03c748; WORD $0xffff; BYTE $0xff // movq $-2, (%rbx) - LONG $0x00028fe9; BYTE $0x00 // jmp LBB19_52, $655(%rip) +LBB15_6: + WORD $0x894c; BYTE $0x2e // movq %r13, (%rsi) -LBB19_6: - WORD $0xf980; BYTE $0x30 // cmpb $48, %cl - LONG $0x0032850f; WORD $0x0000 // jne LBB19_10, $50(%rip) - LONG $0x01488d48 // leaq $1(%rax), %rcx +LBB15_7: + LONG $0xff06c749; WORD $0xffff; BYTE $0xff // movq $-1, (%r14) + +LBB15_8: + LONG $0x38c48348 // addq $56, %rsp + BYTE $0x5b // popq %rbx + WORD $0x5c41 // popq %r12 + WORD $0x5d41 // popq %r13 + WORD $0x5e41 // popq %r14 + WORD $0x5f41 // popq %r15 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB15_9: + LONG $0x30ff8040 // cmpb $48, %dil + LONG $0x0035850f; WORD $0x0000 // jne LBB15_13, $53(%rip) + LONG $0x01488d4c // leaq $1(%rax), %r9 WORD $0x394c; BYTE $0xe8 // cmpq %r13, %rax - LONG $0x00a6830f; WORD $0x0000 // jae LBB19_18, $166(%rip) - LONG $0x14b60f41; BYTE $0x0f // movzbl (%r15,%rcx), %edx - WORD $0xc283; BYTE $0xd2 // addl $-46, %edx - WORD $0xfa83; BYTE $0x37 // cmpl $55, %edx - LONG $0x0095870f; WORD $0x0000 // ja LBB19_18, $149(%rip) - QUAD $0x000000800001be48; WORD $0x0080 // movabsq $36028797027352577, %rsi - LONG $0xd6a30f48 // btq %rdx, %rsi - LONG $0x0081830f; WORD $0x0000 // jae LBB19_18, $129(%rip) + LONG $0x00bf830f; WORD $0x0000 // jae LBB15_22, $191(%rip) + LONG $0x0f148a43 // movb (%r15,%r9), %dl + WORD $0xc280; BYTE $0xd2 // addb $-46, %dl + WORD $0xfa80; BYTE $0x37 // cmpb $55, %dl + LONG $0x00af870f; WORD $0x0000 // ja LBB15_22, $175(%rip) + LONG $0xc2b60f44 // movzbl %dl, %r8d + QUAD $0x000000800001ba48; WORD $0x0080 // movabsq $36028797027352577, %rdx + LONG $0xc2a30f4c // btq %r8, %rdx + LONG $0x0097830f; WORD $0x0000 // jae LBB15_22, $151(%rip) -LBB19_10: - WORD $0x7d89; BYTE $0xd4 // movl %edi, $-44(%rbp) - WORD $0x01b1 // movb $1, %cl - WORD $0x4d89; BYTE $0xc8 // movl %ecx, $-56(%rbp) +LBB15_13: WORD $0x394c; BYTE $0xe8 // cmpq %r13, %rax - LONG $0x0063830f; WORD $0x0000 // jae LBB19_17, $99(%rip) - WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d - LONG $0xffd0b941; WORD $0xffff // movl $4294967248, %r9d - WORD $0x3145; BYTE $0xc0 // xorl %r8d, %r8d + LONG $0xa05d8948 // movq %rbx, $-96(%rbp) + LONG $0xc0558944 // movl %r10d, $-64(%rbp) + LONG $0xd0758948 // movq %rsi, $-48(%rbp) + LONG $0x0075830f; WORD $0x0000 // jae LBB15_21, $117(%rip) + WORD $0xf980; BYTE $0x09 // cmpb $9, %cl + LONG $0x0081870f; WORD $0x0000 // ja LBB15_23, $129(%rip) + LONG $0xffd0b841; WORD $0xffff // movl $4294967248, %r8d + LONG $0xff4d8d4d // leaq $-1(%r13), %r9 WORD $0xc931 // xorl %ecx, %ecx - LONG $0x000012e9; BYTE $0x00 // jmp LBB19_13, $18(%rip) - LONG $0x90909090 // .p2align 4, 0x90 + WORD $0x3145; BYTE $0xd2 // xorl %r10d, %r10d + WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d + LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 -LBB19_12: - WORD $0xc1ff // incl %ecx - WORD $0xff48; BYTE $0xc0 // incq %rax - WORD $0x3949; BYTE $0xc5 // cmpq %rax, %r13 - LONG $0x0036840f; WORD $0x0000 // je LBB19_16, $54(%rip) +LBB15_16: + LONG $0x12fa8341 // cmpl $18, %r10d + LONG $0x00268f0f; WORD $0x0000 // jg LBB15_18, $38(%rip) + LONG $0xa4148d4b // leaq (%r12,%r12,4), %rdx + LONG $0xffbe0f40 // movsbl %dil, %edi + WORD $0x0144; BYTE $0xc7 // addl %r8d, %edi + LONG $0x57248d4c // leaq (%rdi,%rdx,2), %r12 + WORD $0xff41; BYTE $0xc2 // incl %r10d + LONG $0x000011e9; BYTE $0x00 // jmp LBB15_19, $17(%rip) + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 -LBB19_13: - LONG $0x14be0f49; BYTE $0x07 // movsbq (%r15,%rax), %rdx - WORD $0x7a8d; BYTE $0xd0 // leal $-48(%rdx), %edi - LONG $0x09ff8040 // cmpb $9, %dil - LONG $0x0041870f; WORD $0x0000 // ja LBB19_19, $65(%rip) - LONG $0x12f88341 // cmpl $18, %r8d - LONG $0xffd68f0f; WORD $0xffff // jg LBB19_12, $-42(%rip) - LONG $0xa43c8d4b // leaq (%r12,%r12,4), %rdi - WORD $0x0144; BYTE $0xca // addl %r9d, %edx - LONG $0x7a248d4c // leaq (%rdx,%rdi,2), %r12 - WORD $0xff41; BYTE $0xc0 // incl %r8d - WORD $0xff48; BYTE $0xc0 // incq %rax - WORD $0x3949; BYTE $0xc5 // cmpq %rax, %r13 - LONG $0xffca850f; WORD $0xffff // jne LBB19_13, $-54(%rip) +LBB15_18: + WORD $0xc1ff // incl %ecx -LBB19_16: - WORD $0x894c; BYTE $0xe8 // movq %r13, %rax - LONG $0x00005be9; BYTE $0x00 // jmp LBB19_24, $91(%rip) +LBB15_19: + WORD $0x3949; BYTE $0xc1 // cmpq %rax, %r9 + LONG $0x0079840f; WORD $0x0000 // je LBB15_28, $121(%rip) + LONG $0x7cb60f41; WORD $0x0107 // movzbl $1(%r15,%rax), %edi + WORD $0xff48; BYTE $0xc0 // incq %rax + WORD $0x578d; BYTE $0xd0 // leal $-48(%rdi), %edx + WORD $0xfa80; BYTE $0x0a // cmpb $10, %dl + LONG $0xffb0820f; WORD $0xffff // jb LBB15_16, $-80(%rip) + LONG $0x00001de9; BYTE $0x00 // jmp LBB15_24, $29(%rip) -LBB19_17: +LBB15_21: WORD $0xc931 // xorl %ecx, %ecx - WORD $0x3145; BYTE $0xc0 // xorl %r8d, %r8d + WORD $0x3145; BYTE $0xd2 // xorl %r10d, %r10d WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d - LONG $0x00004ee9; BYTE $0x00 // jmp LBB19_24, $78(%rip) + LONG $0x000055e9; BYTE $0x00 // jmp LBB15_29, $85(%rip) -LBB19_18: - WORD $0x8949; BYTE $0x0e // movq %rcx, (%r14) - LONG $0x0001cbe9; BYTE $0x00 // jmp LBB19_52, $459(%rip) +LBB15_22: + WORD $0x894c; BYTE $0x0e // movq %r9, (%rsi) + LONG $0xffff13e9; BYTE $0xff // jmp LBB15_8, $-237(%rip) -LBB19_19: - WORD $0xfa80; BYTE $0x2e // cmpb $46, %dl - LONG $0x003d850f; WORD $0x0000 // jne LBB19_24, $61(%rip) - LONG $0x01508d48 // leaq $1(%rax), %rdx - LONG $0x0803c748; WORD $0x0000; BYTE $0x00 // movq $8, (%rbx) - WORD $0x394c; BYTE $0xea // cmpq %r13, %rdx - LONG $0x01a4830f; WORD $0x0000 // jae LBB19_51, $420(%rip) - LONG $0x44b60f41; WORD $0x0107 // movzbl $1(%r15,%rax), %eax - WORD $0xc604 // addb $-58, %al - WORD $0xf53c // cmpb $-11, %al - LONG $0x000f870f; WORD $0x0000 // ja LBB19_23, $15(%rip) - WORD $0x8949; BYTE $0x16 // movq %rdx, (%r14) - LONG $0xfe03c748; WORD $0xffff; BYTE $0xff // movq $-2, (%rbx) - LONG $0x00018fe9; BYTE $0x00 // jmp LBB19_52, $399(%rip) - -LBB19_23: - LONG $0x00c845c7; WORD $0x0000; BYTE $0x00 // movl $0, $-56(%rbp) - WORD $0x8948; BYTE $0xd0 // movq %rdx, %rax +LBB15_23: + WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d + WORD $0x3145; BYTE $0xd2 // xorl %r10d, %r10d + WORD $0xc931 // xorl %ecx, %ecx -LBB19_24: - WORD $0xd231 // xorl %edx, %edx - WORD $0xc985 // testl %ecx, %ecx - WORD $0x9f0f; BYTE $0xc2 // setg %dl - WORD $0x5589; BYTE $0xbc // movl %edx, $-68(%rbp) - WORD $0x854d; BYTE $0xe4 // testq %r12, %r12 - LONG $0x005d850f; WORD $0x0000 // jne LBB19_33, $93(%rip) - WORD $0xc985 // testl %ecx, %ecx - LONG $0x0055850f; WORD $0x0000 // jne LBB19_33, $85(%rip) - WORD $0x394c; BYTE $0xe8 // cmpq %r13, %rax - LONG $0x0044830f; WORD $0x0000 // jae LBB19_31, $68(%rip) - WORD $0xc689 // movl %eax, %esi - WORD $0x2944; BYTE $0xee // subl %r13d, %esi - WORD $0x3145; BYTE $0xc0 // xorl %r8d, %r8d - WORD $0xc931 // xorl %ecx, %ecx - QUAD $0x9090909090909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 +LBB15_24: + WORD $0xd231 // xorl %edx, %edx + WORD $0xc985 // testl %ecx, %ecx + WORD $0x9f0f; BYTE $0xc2 // setg %dl + WORD $0x5589; BYTE $0xc4 // movl %edx, $-60(%rbp) + WORD $0xb041; BYTE $0x01 // movb $1, %r8b + LONG $0x2eff8040 // cmpb $46, %dil + LONG $0x003b850f; WORD $0x0000 // jne LBB15_30, $59(%rip) + WORD $0xff48; BYTE $0xc0 // incq %rax + LONG $0x0806c749; WORD $0x0000; BYTE $0x00 // movq $8, (%r14) + WORD $0x394c; BYTE $0xe8 // cmpq %r13, %rax + LONG $0x0268830f; WORD $0x0000 // jae LBB15_68, $616(%rip) + LONG $0x07148a41 // movb (%r15,%rax), %dl + WORD $0xc280; BYTE $0xd0 // addb $-48, %dl + WORD $0xfa80; BYTE $0x0a // cmpb $10, %dl + LONG $0x0401830f; WORD $0x0000 // jae LBB15_91, $1025(%rip) + WORD $0x3145; BYTE $0xc0 // xorl %r8d, %r8d + LONG $0x000010e9; BYTE $0x00 // jmp LBB15_30, $16(%rip) -LBB19_28: +LBB15_28: + WORD $0x894c; BYTE $0xe8 // movq %r13, %rax + +LBB15_29: + WORD $0xd231 // xorl %edx, %edx + WORD $0xc985 // testl %ecx, %ecx + WORD $0x9f0f; BYTE $0xc2 // setg %dl + WORD $0x5589; BYTE $0xc4 // movl %edx, $-60(%rbp) + WORD $0xb041; BYTE $0x01 // movb $1, %r8b + +LBB15_30: + WORD $0xc985 // testl %ecx, %ecx + LONG $0x0056850f; WORD $0x0000 // jne LBB15_39, $86(%rip) + WORD $0x854d; BYTE $0xe4 // testq %r12, %r12 + LONG $0x004d850f; WORD $0x0000 // jne LBB15_39, $77(%rip) + WORD $0x394c; BYTE $0xe8 // cmpq %r13, %rax + LONG $0x003c830f; WORD $0x0000 // jae LBB15_37, $60(%rip) + WORD $0xc689 // movl %eax, %esi + WORD $0x2944; BYTE $0xee // subl %r13d, %esi + WORD $0x3145; BYTE $0xd2 // xorl %r10d, %r10d + WORD $0xc931 // xorl %ecx, %ecx + QUAD $0x9090909090909090 // .p2align 4, 0x90 + +LBB15_34: LONG $0x073c8041; BYTE $0x30 // cmpb $48, (%r15,%rax) - LONG $0x0029850f; WORD $0x0000 // jne LBB19_32, $41(%rip) + LONG $0x0024850f; WORD $0x0000 // jne LBB15_38, $36(%rip) WORD $0xff48; BYTE $0xc0 // incq %rax WORD $0xc9ff // decl %ecx WORD $0x3949; BYTE $0xc5 // cmpq %rax, %r13 - LONG $0xffe7850f; WORD $0xffff // jne LBB19_28, $-25(%rip) + LONG $0xffe7850f; WORD $0xffff // jne LBB15_34, $-25(%rip) WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d - WORD $0x458b; BYTE $0xc8 // movl $-56(%rbp), %eax - WORD $0xc084 // testb %al, %al - LONG $0x0144850f; WORD $0x0000 // jne LBB19_54, $324(%rip) - -LBB19_59: - WORD $0x558b; BYTE $0xd4 // movl $-44(%rbp), %edx - LONG $0x000173e9; BYTE $0x00 // jmp LBB19_60, $371(%rip) + WORD $0x8445; BYTE $0xc0 // testb %r8b, %r8b + LONG $0x0122850f; WORD $0x0000 // jne LBB15_58, $290(%rip) + LONG $0x000152e9; BYTE $0x00 // jmp LBB15_62, $338(%rip) -LBB19_31: +LBB15_37: WORD $0xc931 // xorl %ecx, %ecx - WORD $0x3145; BYTE $0xc0 // xorl %r8d, %r8d + WORD $0x3145; BYTE $0xd2 // xorl %r10d, %r10d -LBB19_32: +LBB15_38: WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d -LBB19_33: +LBB15_39: WORD $0x394c; BYTE $0xe8 // cmpq %r13, %rax - LONG $0x004c830f; WORD $0x0000 // jae LBB19_39, $76(%rip) - LONG $0x12f88341 // cmpl $18, %r8d - LONG $0x00428f0f; WORD $0x0000 // jg LBB19_39, $66(%rip) + LONG $0x0051830f; WORD $0x0000 // jae LBB15_45, $81(%rip) + LONG $0x12fa8341 // cmpl $18, %r10d + LONG $0x00478f0f; WORD $0x0000 // jg LBB15_45, $71(%rip) LONG $0xffd0b941; WORD $0xffff // movl $4294967248, %r9d + LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 - // .p2align 4, 0x90 -LBB19_36: +LBB15_42: LONG $0x14b60f41; BYTE $0x07 // movzbl (%r15,%rax), %edx WORD $0x7a8d; BYTE $0xd0 // leal $-48(%rdx), %edi LONG $0x09ff8040 // cmpb $9, %dil - LONG $0x002a870f; WORD $0x0000 // ja LBB19_39, $42(%rip) + LONG $0x002a870f; WORD $0x0000 // ja LBB15_45, $42(%rip) LONG $0xa43c8d4b // leaq (%r12,%r12,4), %rdi WORD $0x0144; BYTE $0xca // addl %r9d, %edx LONG $0x7a248d4c // leaq (%rdx,%rdi,2), %r12 WORD $0xc9ff // decl %ecx WORD $0xff48; BYTE $0xc0 // incq %rax WORD $0x394c; BYTE $0xe8 // cmpq %r13, %rax - LONG $0x0011830f; WORD $0x0000 // jae LBB19_39, $17(%rip) - LONG $0x01508d41 // leal $1(%r8), %edx - LONG $0x12f88341 // cmpl $18, %r8d - WORD $0x8941; BYTE $0xd0 // movl %edx, %r8d - LONG $0xffc48c0f; WORD $0xffff // jl LBB19_36, $-60(%rip) + LONG $0x0011830f; WORD $0x0000 // jae LBB15_45, $17(%rip) + LONG $0x01528d41 // leal $1(%r10), %edx + LONG $0x12fa8341 // cmpl $18, %r10d + WORD $0x8941; BYTE $0xd2 // movl %edx, %r10d + LONG $0xffc48c0f; WORD $0xffff // jl LBB15_42, $-60(%rip) -LBB19_39: - WORD $0x394c; BYTE $0xe8 // cmpq %r13, %rax - LONG $0x00c6830f; WORD $0x0000 // jae LBB19_53, $198(%rip) - LONG $0x34b60f41; BYTE $0x07 // movzbl (%r15,%rax), %esi - WORD $0x568d; BYTE $0xd0 // leal $-48(%rsi), %edx - WORD $0xfa80; BYTE $0x09 // cmpb $9, %dl - LONG $0x0030870f; WORD $0x0000 // ja LBB19_45, $48(%rip) - LONG $0xff558d49 // leaq $-1(%r13), %rdx - LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 +LBB15_45: + WORD $0x394c; BYTE $0xe8 // cmpq %r13, %rax + LONG $0x00a4830f; WORD $0x0000 // jae LBB15_57, $164(%rip) + LONG $0x07348a41 // movb (%r15,%rax), %sil + WORD $0x568d; BYTE $0xd0 // leal $-48(%rsi), %edx + WORD $0xfa80; BYTE $0x09 // cmpb $9, %dl + LONG $0x0030870f; WORD $0x0000 // ja LBB15_51, $48(%rip) + LONG $0xff7d8d49 // leaq $-1(%r13), %rdi + LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 -LBB19_42: - WORD $0x3948; BYTE $0xc2 // cmpq %rax, %rdx - LONG $0x0180840f; WORD $0x0000 // je LBB19_58, $384(%rip) +LBB15_48: + WORD $0x3948; BYTE $0xc7 // cmpq %rax, %rdi + LONG $0x0167840f; WORD $0x0000 // je LBB15_69, $359(%rip) LONG $0x74b60f41; WORD $0x0107 // movzbl $1(%r15,%rax), %esi - WORD $0x7e8d; BYTE $0xd0 // leal $-48(%rsi), %edi WORD $0xff48; BYTE $0xc0 // incq %rax - LONG $0x09ff8040 // cmpb $9, %dil - LONG $0xffe1860f; WORD $0xffff // jbe LBB19_42, $-31(%rip) - LONG $0x01bc45c7; WORD $0x0000; BYTE $0x00 // movl $1, $-68(%rbp) + WORD $0x568d; BYTE $0xd0 // leal $-48(%rsi), %edx + WORD $0xfa80; BYTE $0x09 // cmpb $9, %dl + LONG $0xffe2860f; WORD $0xffff // jbe LBB15_48, $-30(%rip) + LONG $0x01c445c7; WORD $0x0000; BYTE $0x00 // movl $1, $-60(%rbp) -LBB19_45: - LONG $0xd6b60f40 // movzbl %sil, %edx - WORD $0xca83; BYTE $0x20 // orl $32, %edx - WORD $0xfa83; BYTE $0x65 // cmpl $101, %edx - LONG $0x0075850f; WORD $0x0000 // jne LBB19_53, $117(%rip) +LBB15_51: + LONG $0x20ce8040 // orb $32, %sil + LONG $0x65fe8040 // cmpb $101, %sil + LONG $0x0056850f; WORD $0x0000 // jne LBB15_57, $86(%rip) LONG $0x01788d48 // leaq $1(%rax), %rdi - LONG $0x0803c748; WORD $0x0000; BYTE $0x00 // movq $8, (%rbx) + LONG $0x0806c749; WORD $0x0000; BYTE $0x00 // movq $8, (%r14) WORD $0x394c; BYTE $0xef // cmpq %r13, %rdi - LONG $0x0048830f; WORD $0x0000 // jae LBB19_51, $72(%rip) - LONG $0x34b60f41; BYTE $0x3f // movzbl (%r15,%rdi), %esi - WORD $0xfe83; BYTE $0x2d // cmpl $45, %esi - LONG $0x000f840f; WORD $0x0000 // je LBB19_49, $15(%rip) + LONG $0x011d830f; WORD $0x0000 // jae LBB15_68, $285(%rip) + LONG $0x3f348a41 // movb (%r15,%rdi), %sil + LONG $0x2dfe8040 // cmpb $45, %sil + LONG $0x0010840f; WORD $0x0000 // je LBB15_55, $16(%rip) LONG $0x0001b841; WORD $0x0000 // movl $1, %r8d - WORD $0xfe83; BYTE $0x2b // cmpl $43, %esi - LONG $0x02a8850f; WORD $0x0000 // jne LBB19_86, $680(%rip) + LONG $0x2bfe8040 // cmpb $43, %sil + LONG $0x0298850f; WORD $0x0000 // jne LBB15_89, $664(%rip) -LBB19_49: +LBB15_55: LONG $0x02c08348 // addq $2, %rax WORD $0x394c; BYTE $0xe8 // cmpq %r13, %rax - WORD $0x558b; BYTE $0xd4 // movl $-44(%rbp), %edx - LONG $0x001b830f; WORD $0x0000 // jae LBB19_51, $27(%rip) - WORD $0xff31 // xorl %edi, %edi + LONG $0x00f2830f; WORD $0x0000 // jae LBB15_68, $242(%rip) + WORD $0xd231 // xorl %edx, %edx LONG $0x2bfe8040 // cmpb $43, %sil - LONG $0xc7940f40 // sete %dil - LONG $0x3f048d44 // leal (%rdi,%rdi), %r8d - WORD $0xff41; BYTE $0xc8 // decl %r8d - LONG $0x34b60f41; BYTE $0x07 // movzbl (%r15,%rax), %esi - LONG $0x000283e9; BYTE $0x00 // jmp LBB19_87, $643(%rip) + WORD $0x940f; BYTE $0xc2 // sete %dl + LONG $0x12448d44; BYTE $0xff // leal $-1(%rdx,%rdx), %r8d + LONG $0x07348a41 // movb (%r15,%rax), %sil + LONG $0x000277e9; BYTE $0x00 // jmp LBB15_90, $631(%rip) -LBB19_51: - WORD $0x894d; BYTE $0x2e // movq %r13, (%r14) - LONG $0xff03c748; WORD $0xffff; BYTE $0xff // movq $-1, (%rbx) - -LBB19_52: - LONG $0x38c48348 // addq $56, %rsp - BYTE $0x5b // popq %rbx - WORD $0x5c41 // popq %r12 - WORD $0x5d41 // popq %r13 - WORD $0x5e41 // popq %r14 - WORD $0x5f41 // popq %r15 - BYTE $0x5d // popq %rbp - BYTE $0xc3 // retq - -LBB19_53: +LBB15_57: WORD $0xce89 // movl %ecx, %esi WORD $0x8949; BYTE $0xc5 // movq %rax, %r13 - WORD $0x458b; BYTE $0xc8 // movl $-56(%rbp), %eax - WORD $0xc084 // testb %al, %al - LONG $0xfebc840f; WORD $0xffff // je LBB19_59, $-324(%rip) + WORD $0x8445; BYTE $0xc0 // testb %r8b, %r8b + LONG $0x0035840f; WORD $0x0000 // je LBB15_62, $53(%rip) -LBB19_54: +LBB15_58: WORD $0xf685 // testl %esi, %esi - WORD $0x558b; BYTE $0xd4 // movl $-44(%rbp), %edx - LONG $0x0025850f; WORD $0x0000 // jne LBB19_57, $37(%rip) + LONG $0x0026850f; WORD $0x0000 // jne LBB15_61, $38(%rip) QUAD $0x000000000000b848; WORD $0x8000 // movabsq $-9223372036854775808, %rax - WORD $0x6348; BYTE $0xca // movslq %edx, %rcx + LONG $0xc04d6348 // movslq $-64(%rbp), %rcx WORD $0x854d; BYTE $0xe4 // testq %r12, %r12 - LONG $0x00e7890f; WORD $0x0000 // jns LBB19_68, $231(%rip) - WORD $0x894c; BYTE $0xe7 // movq %r12, %rdi - WORD $0x2148; BYTE $0xcf // andq %rcx, %rdi - WORD $0x3948; BYTE $0xc7 // cmpq %rax, %rdi - LONG $0x00d8840f; WORD $0x0000 // je LBB19_68, $216(%rip) + LONG $0x00f2890f; WORD $0x0000 // jns LBB15_72, $242(%rip) + WORD $0x894c; BYTE $0xe2 // movq %r12, %rdx + WORD $0x2148; BYTE $0xca // andq %rcx, %rdx + WORD $0x3948; BYTE $0xc2 // cmpq %rax, %rdx + LONG $0x00e3840f; WORD $0x0000 // je LBB15_72, $227(%rip) -LBB19_57: - LONG $0x0803c748; WORD $0x0000; BYTE $0x00 // movq $8, (%rbx) +LBB15_61: + LONG $0x0806c749; WORD $0x0000; BYTE $0x00 // movq $8, (%r14) -LBB19_60: +LBB15_62: + QUAD $0x00000000b845c748 // movq $0, $-72(%rbp) LONG $0x6ef9c1c4; BYTE $0xc4 // vmovq %r12, %xmm0 - QUAD $0xfffffc510562f9c5 // vpunpckldq $-943(%rip), %xmm0, %xmm0 /* LCPI19_0(%rip) */ - QUAD $0x00000000b045c748 // movq $0, $-80(%rbp) - QUAD $0xfffffc51055cf9c5 // vsubpd $-943(%rip), %xmm0, %xmm0 /* LCPI19_1(%rip) */ + QUAD $0xfffffc2f0562f9c5 // vpunpckldq $-977(%rip), %xmm0, %xmm0 /* LCPI15_0(%rip) */ + QUAD $0xfffffc37055cf9c5 // vsubpd $-969(%rip), %xmm0, %xmm0 /* LCPI15_1(%rip) */ LONG $0x0579e3c4; WORD $0x01c8 // vpermilpd $1, %xmm0, %xmm1 LONG $0xc058f3c5 // vaddsd %xmm0, %xmm1, %xmm0 - LONG $0x4511fbc5; BYTE $0xc0 // vmovsd %xmm0, $-64(%rbp) + LONG $0x4511fbc5; BYTE $0xc8 // vmovsd %xmm0, $-56(%rbp) WORD $0x894c; BYTE $0xe0 // movq %r12, %rax LONG $0x34e8c148 // shrq $52, %rax - LONG $0x010d850f; WORD $0x0000 // jne LBB19_73, $269(%rip) + LONG $0x011f850f; WORD $0x0000 // jne LBB15_77, $287(%rip) LONG $0x7ef9e1c4; BYTE $0xc1 // vmovq %xmm0, %rcx - WORD $0xd089 // movl %edx, %eax + WORD $0x458b; BYTE $0xc0 // movl $-64(%rbp), %eax WORD $0xe8c1; BYTE $0x1f // shrl $31, %eax LONG $0x3fe0c148 // shlq $63, %rax WORD $0x0948; BYTE $0xc8 // orq %rcx, %rax - LONG $0xc0458948 // movq %rax, $-64(%rbp) + LONG $0xc8458948 // movq %rax, $-56(%rbp) WORD $0x854d; BYTE $0xe4 // testq %r12, %r12 - LONG $0x018a840f; WORD $0x0000 // je LBB19_81, $394(%rip) + LONG $0x019f840f; WORD $0x0000 // je LBB15_85, $415(%rip) WORD $0xf685 // testl %esi, %esi - LONG $0x0182840f; WORD $0x0000 // je LBB19_81, $386(%rip) + LONG $0x0197840f; WORD $0x0000 // je LBB15_85, $407(%rip) LONG $0x6ef9e1c4; BYTE $0xc0 // vmovq %rax, %xmm0 WORD $0x468d; BYTE $0xff // leal $-1(%rsi), %eax WORD $0xf883; BYTE $0x24 // cmpl $36, %eax - LONG $0x0040870f; WORD $0x0000 // ja LBB19_66, $64(%rip) + LONG $0x004a870f; WORD $0x0000 // ja LBB15_70, $74(%rip) WORD $0xfe83; BYTE $0x17 // cmpl $23, %esi - LONG $0x0093820f; WORD $0x0000 // jb LBB19_69, $147(%rip) + LONG $0x00a48c0f; WORD $0x0000 // jl LBB15_73, $164(%rip) WORD $0x468d; BYTE $0xea // leal $-22(%rsi), %eax - LONG $0xab0d8d48; WORD $0x00ed; BYTE $0x00 // leaq $60843(%rip), %rcx /* _P10_TAB(%rip) */ + LONG $0xe00d8d48; WORD $0x00ec; BYTE $0x00 // leaq $60640(%rip), %rcx /* _P10_TAB(%rip) */ LONG $0x0459fbc5; BYTE $0xc1 // vmulsd (%rcx,%rax,8), %xmm0, %xmm0 - LONG $0x4511fbc5; BYTE $0xc0 // vmovsd %xmm0, $-64(%rbp) + LONG $0x4511fbc5; BYTE $0xc8 // vmovsd %xmm0, $-56(%rbp) LONG $0x000016b8; BYTE $0x00 // movl $22, %eax - LONG $0x000077e9; BYTE $0x00 // jmp LBB19_70, $119(%rip) + LONG $0x000088e9; BYTE $0x00 // jmp LBB15_74, $136(%rip) -LBB19_58: - LONG $0x01bc45c7; WORD $0x0000; BYTE $0x00 // movl $1, $-68(%rbp) +LBB15_68: + LONG $0xd0458b48 // movq $-48(%rbp), %rax + WORD $0x894c; BYTE $0x28 // movq %r13, (%rax) + LONG $0xfffc66e9; BYTE $0xff // jmp LBB15_7, $-922(%rip) + +LBB15_69: + LONG $0x01c445c7; WORD $0x0000; BYTE $0x00 // movl $1, $-60(%rbp) WORD $0xce89 // movl %ecx, %esi - WORD $0x458b; BYTE $0xc8 // movl $-56(%rbp), %eax - WORD $0xc084 // testb %al, %al - LONG $0xff1e850f; WORD $0xffff // jne LBB19_54, $-226(%rip) - LONG $0xfffdd5e9; BYTE $0xff // jmp LBB19_59, $-555(%rip) + WORD $0x8445; BYTE $0xc0 // testb %r8b, %r8b + LONG $0xff15850f; WORD $0xffff // jne LBB15_58, $-235(%rip) + LONG $0xffff45e9; BYTE $0xff // jmp LBB15_62, $-187(%rip) -LBB19_66: +LBB15_70: WORD $0xfe83; BYTE $0xea // cmpl $-22, %esi - LONG $0x008d820f; WORD $0x0000 // jb LBB19_73, $141(%rip) + LONG $0x0094820f; WORD $0x0000 // jb LBB15_77, $148(%rip) WORD $0xdef7 // negl %esi - LONG $0x6c058d48; WORD $0x00ed; BYTE $0x00 // leaq $60780(%rip), %rax /* _P10_TAB(%rip) */ + LONG $0x97058d48; WORD $0x00ec; BYTE $0x00 // leaq $60567(%rip), %rax /* _P10_TAB(%rip) */ LONG $0x045efbc5; BYTE $0xf0 // vdivsd (%rax,%rsi,8), %xmm0, %xmm0 - LONG $0x4511fbc5; BYTE $0xc0 // vmovsd %xmm0, $-64(%rbp) - LONG $0x0000d7e9; BYTE $0x00 // jmp LBB19_77, $215(%rip) + LONG $0x4511fbc5; BYTE $0xc8 // vmovsd %xmm0, $-56(%rbp) + LONG $0x0000dee9; BYTE $0x00 // jmp LBB15_81, $222(%rip) -LBB19_68: +LBB15_72: LONG $0x6ef9c1c4; BYTE $0xc4 // vmovq %r12, %xmm0 LONG $0xe1af0f4c // imulq %rcx, %r12 - QUAD $0xfffffb7c0562f9c5 // vpunpckldq $-1156(%rip), %xmm0, %xmm0 /* LCPI19_0(%rip) */ - QUAD $0xfffffb84055cf9c5 // vsubpd $-1148(%rip), %xmm0, %xmm0 /* LCPI19_1(%rip) */ - LONG $0x1063894c // movq %r12, $16(%rbx) + QUAD $0xfffffb570562f9c5 // vpunpckldq $-1193(%rip), %xmm0, %xmm0 /* LCPI15_0(%rip) */ + QUAD $0xfffffb5f055cf9c5 // vsubpd $-1185(%rip), %xmm0, %xmm0 /* LCPI15_1(%rip) */ + LONG $0x1066894d // movq %r12, $16(%r14) LONG $0x0579e3c4; WORD $0x01c8 // vpermilpd $1, %xmm0, %xmm1 LONG $0xc058f3c5 // vaddsd %xmm0, %xmm1, %xmm0 WORD $0x2148; BYTE $0xc8 // andq %rcx, %rax LONG $0x7ef9e1c4; BYTE $0xc1 // vmovq %xmm0, %rcx WORD $0x0948; BYTE $0xc1 // orq %rax, %rcx - LONG $0x084b8948 // movq %rcx, $8(%rbx) - LONG $0x000109e9; BYTE $0x00 // jmp LBB19_85, $265(%rip) + LONG $0x084e8949 // movq %rcx, $8(%r14) + LONG $0xd0458b48 // movq $-48(%rbp), %rax + WORD $0x894c; BYTE $0x28 // movq %r13, (%rax) + LONG $0xfffbf3e9; BYTE $0xff // jmp LBB15_8, $-1037(%rip) -LBB19_69: +LBB15_73: WORD $0xf089 // movl %esi, %eax -LBB19_70: - QUAD $0xfffffb68052ef9c5 // vucomisd $-1176(%rip), %xmm0 /* LCPI19_2(%rip) */ - LONG $0x002a870f; WORD $0x0000 // ja LBB19_73, $42(%rip) - QUAD $0xfffffb620d10fbc5 // vmovsd $-1182(%rip), %xmm1 /* LCPI19_3(%rip) */ +LBB15_74: + QUAD $0xfffffb3c052ef9c5 // vucomisd $-1220(%rip), %xmm0 /* LCPI15_2(%rip) */ + LONG $0x002a870f; WORD $0x0000 // ja LBB15_77, $42(%rip) + QUAD $0xfffffb360d10fbc5 // vmovsd $-1226(%rip), %xmm1 /* LCPI15_3(%rip) */ LONG $0xc82ef9c5 // vucomisd %xmm0, %xmm1 - LONG $0x0018870f; WORD $0x0000 // ja LBB19_73, $24(%rip) + LONG $0x0018870f; WORD $0x0000 // ja LBB15_77, $24(%rip) WORD $0xc089 // movl %eax, %eax - LONG $0xf70d8d48; WORD $0x00ec; BYTE $0x00 // leaq $60663(%rip), %rcx /* _P10_TAB(%rip) */ + LONG $0x1b0d8d48; WORD $0x00ec; BYTE $0x00 // leaq $60443(%rip), %rcx /* _P10_TAB(%rip) */ LONG $0x0459fbc5; BYTE $0xc1 // vmulsd (%rcx,%rax,8), %xmm0, %xmm0 - LONG $0x4511fbc5; BYTE $0xc0 // vmovsd %xmm0, $-64(%rbp) - LONG $0x000062e9; BYTE $0x00 // jmp LBB19_77, $98(%rip) + LONG $0x4511fbc5; BYTE $0xc8 // vmovsd %xmm0, $-56(%rbp) + LONG $0x000062e9; BYTE $0x00 // jmp LBB15_81, $98(%rip) -LBB19_73: - LONG $0xa05d894c // movq %r11, $-96(%rbp) - LONG $0xc855894c // movq %r10, $-56(%rbp) - LONG $0xc04d8d48 // leaq $-64(%rbp), %rcx +LBB15_77: + LONG $0xa85d894c // movq %r11, $-88(%rbp) + LONG $0xc84d8d48 // leaq $-56(%rbp), %rcx WORD $0x894c; BYTE $0xe7 // movq %r12, %rdi - LONG $0xa8758948 // movq %rsi, $-88(%rbp) - LONG $0xffe0c0e8; BYTE $0xff // callq _atof_eisel_lemire64, $-8000(%rip) + WORD $0x5d8b; BYTE $0xc0 // movl $-64(%rbp), %ebx + WORD $0xda89 // movl %ebx, %edx + LONG $0xb0758948 // movq %rsi, $-80(%rbp) + LONG $0xffe423e8; BYTE $0xff // callq _atof_eisel_lemire64, $-7133(%rip) WORD $0xc084 // testb %al, %al - LONG $0x004c840f; WORD $0x0000 // je LBB19_79, $76(%rip) - LONG $0x00bc7d83 // cmpl $0, $-68(%rbp) - LONG $0x006d840f; WORD $0x0000 // je LBB19_80, $109(%rip) + LONG $0x004b840f; WORD $0x0000 // je LBB15_83, $75(%rip) + LONG $0xb0758b48 // movq $-80(%rbp), %rsi + LONG $0x00c47d83 // cmpl $0, $-60(%rbp) + LONG $0x006c840f; WORD $0x0000 // je LBB15_84, $108(%rip) WORD $0xff49; BYTE $0xc4 // incq %r12 - LONG $0xb04d8d48 // leaq $-80(%rbp), %rcx + LONG $0xb84d8d48 // leaq $-72(%rbp), %rcx WORD $0x894c; BYTE $0xe7 // movq %r12, %rdi - LONG $0xa8758b48 // movq $-88(%rbp), %rsi - WORD $0x558b; BYTE $0xd4 // movl $-44(%rbp), %edx - LONG $0xffe098e8; BYTE $0xff // callq _atof_eisel_lemire64, $-8040(%rip) + WORD $0xda89 // movl %ebx, %edx + LONG $0xffe3fce8; BYTE $0xff // callq _atof_eisel_lemire64, $-7172(%rip) WORD $0xc084 // testb %al, %al - LONG $0x0024840f; WORD $0x0000 // je LBB19_79, $36(%rip) - LONG $0x4d10fbc5; BYTE $0xb0 // vmovsd $-80(%rbp), %xmm1 - LONG $0x4510fbc5; BYTE $0xc0 // vmovsd $-64(%rbp), %xmm0 + LONG $0x0024840f; WORD $0x0000 // je LBB15_83, $36(%rip) + LONG $0x4d10fbc5; BYTE $0xb8 // vmovsd $-72(%rbp), %xmm1 + LONG $0x4510fbc5; BYTE $0xc8 // vmovsd $-56(%rbp), %xmm0 LONG $0xc82ef9c5 // vucomisd %xmm0, %xmm1 - LONG $0x0010850f; WORD $0x0000 // jne LBB19_79, $16(%rip) - LONG $0x000a8a0f; WORD $0x0000 // jp LBB19_79, $10(%rip) + LONG $0x0010850f; WORD $0x0000 // jne LBB15_83, $16(%rip) + LONG $0x000a8a0f; WORD $0x0000 // jp LBB15_83, $10(%rip) -LBB19_77: +LBB15_81: LONG $0x7ef9e1c4; BYTE $0xc0 // vmovq %xmm0, %rax - LONG $0x00002fe9; BYTE $0x00 // jmp LBB19_81, $47(%rip) + LONG $0x000033e9; BYTE $0x00 // jmp LBB15_85, $51(%rip) -LBB19_79: - WORD $0x8b49; BYTE $0x06 // movq (%r14), %rax +LBB15_83: + LONG $0xd05d8b48 // movq $-48(%rbp), %rbx + WORD $0x8b48; BYTE $0x03 // movq (%rbx), %rax WORD $0x0149; BYTE $0xc7 // addq %rax, %r15 WORD $0x894c; BYTE $0xee // movq %r13, %rsi WORD $0x2948; BYTE $0xc6 // subq %rax, %rsi WORD $0x894c; BYTE $0xff // movq %r15, %rdi - LONG $0xc8558b48 // movq $-56(%rbp), %rdx - LONG $0xa04d8b48 // movq $-96(%rbp), %rcx - LONG $0xffe810e8; BYTE $0xff // callq _atof_native, $-6128(%rip) - LONG $0x4511fbc5; BYTE $0xc0 // vmovsd %xmm0, $-64(%rbp) + LONG $0xa0558b48 // movq $-96(%rbp), %rdx + LONG $0xa84d8b48 // movq $-88(%rbp), %rcx + LONG $0xffeb30e8; BYTE $0xff // callq _atof_native, $-5328(%rip) + LONG $0x4511fbc5; BYTE $0xc8 // vmovsd %xmm0, $-56(%rbp) LONG $0x7ef9e1c4; BYTE $0xc0 // vmovq %xmm0, %rax - LONG $0x000009e9; BYTE $0x00 // jmp LBB19_82, $9(%rip) + LONG $0x000008e9; BYTE $0x00 // jmp LBB15_86, $8(%rip) -LBB19_80: - LONG $0xc0458b48 // movq $-64(%rbp), %rax +LBB15_84: + LONG $0xc8458b48 // movq $-56(%rbp), %rax -LBB19_81: - LONG $0x6ef9e1c4; BYTE $0xc0 // vmovq %rax, %xmm0 +LBB15_85: + LONG $0xd05d8b48 // movq $-48(%rbp), %rbx -LBB19_82: +LBB15_86: QUAD $0x000000000000b948; WORD $0x8000 // movabsq $-9223372036854775808, %rcx WORD $0xff48; BYTE $0xc9 // decq %rcx WORD $0x2148; BYTE $0xc1 // andq %rax, %rcx - QUAD $0x000000000000b848; WORD $0x7ff0 // movabsq $9218868437227405312, %rax - WORD $0x3948; BYTE $0xc1 // cmpq %rax, %rcx - LONG $0x0007850f; WORD $0x0000 // jne LBB19_84, $7(%rip) - LONG $0xf803c748; WORD $0xffff; BYTE $0xff // movq $-8, (%rbx) + QUAD $0x000000000000ba48; WORD $0x7ff0 // movabsq $9218868437227405312, %rdx + WORD $0x3948; BYTE $0xd1 // cmpq %rdx, %rcx + LONG $0x0007850f; WORD $0x0000 // jne LBB15_88, $7(%rip) + LONG $0xf806c749; WORD $0xffff; BYTE $0xff // movq $-8, (%r14) -LBB19_84: - LONG $0x4311fbc5; BYTE $0x08 // vmovsd %xmm0, $8(%rbx) +LBB15_88: + LONG $0x08468949 // movq %rax, $8(%r14) + WORD $0x894c; BYTE $0x2b // movq %r13, (%rbx) + LONG $0xfffae0e9; BYTE $0xff // jmp LBB15_8, $-1312(%rip) -LBB19_85: - WORD $0x894d; BYTE $0x2e // movq %r13, (%r14) - LONG $0xfffd8de9; BYTE $0xff // jmp LBB19_52, $-627(%rip) - -LBB19_86: +LBB15_89: WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax - WORD $0x558b; BYTE $0xd4 // movl $-44(%rbp), %edx -LBB19_87: - LONG $0xc6c68040 // addb $-58, %sil - LONG $0xf6fe8040 // cmpb $-10, %sil - LONG $0xfadb820f; WORD $0xffff // jb LBB19_5, $-1317(%rip) - WORD $0xf631 // xorl %esi, %esi - WORD $0x394c; BYTE $0xe8 // cmpq %r13, %rax - LONG $0x0035830f; WORD $0x0000 // jae LBB19_93, $53(%rip) - WORD $0xf631 // xorl %esi, %esi +LBB15_90: + WORD $0x7e8d; BYTE $0xd0 // leal $-48(%rsi), %edi + LONG $0x09ff8040 // cmpb $9, %dil + LONG $0x0013860f; WORD $0x0000 // jbe LBB15_92, $19(%rip) -LBB19_90: - LONG $0x0cb60f45; BYTE $0x07 // movzbl (%r15,%rax), %r9d - LONG $0xd0798d41 // leal $-48(%r9), %edi +LBB15_91: + LONG $0xd04d8b48 // movq $-48(%rbp), %rcx + WORD $0x8948; BYTE $0x01 // movq %rax, (%rcx) + LONG $0xfe06c749; WORD $0xffff; BYTE $0xff // movq $-2, (%r14) + LONG $0xfffabde9; BYTE $0xff // jmp LBB15_8, $-1347(%rip) + +LBB15_92: + WORD $0x394c; BYTE $0xe8 // cmpq %r13, %rax + LONG $0x0049830f; WORD $0x0000 // jae LBB15_98, $73(%rip) LONG $0x09ff8040 // cmpb $9, %dil - LONG $0x0020870f; WORD $0x0000 // ja LBB19_93, $32(%rip) - LONG $0x2710fe81; WORD $0x0000 // cmpl $10000, %esi - WORD $0x3c8d; BYTE $0xb6 // leal (%rsi,%rsi,4), %edi - LONG $0x797c8d41; BYTE $0xd0 // leal $-48(%r9,%rdi,2), %edi - WORD $0x4c0f; BYTE $0xf7 // cmovll %edi, %esi + LONG $0x003f870f; WORD $0x0000 // ja LBB15_98, $63(%rip) + LONG $0xff4d8d4d // leaq $-1(%r13), %r9 + WORD $0xff31 // xorl %edi, %edi + +LBB15_95: + WORD $0xfa89 // movl %edi, %edx + LONG $0x2710ff81; WORD $0x0000 // cmpl $10000, %edi + WORD $0x3c8d; BYTE $0x92 // leal (%rdx,%rdx,4), %edi + LONG $0xf6b60f40 // movzbl %sil, %esi + LONG $0xd07e7c8d // leal $-48(%rsi,%rdi,2), %edi + WORD $0x4d0f; BYTE $0xfa // cmovgel %edx, %edi + WORD $0x3949; BYTE $0xc1 // cmpq %rax, %r9 + LONG $0x0021840f; WORD $0x0000 // je LBB15_99, $33(%rip) + LONG $0x74b60f41; WORD $0x0107 // movzbl $1(%r15,%rax), %esi WORD $0xff48; BYTE $0xc0 // incq %rax - WORD $0x3949; BYTE $0xc5 // cmpq %rax, %r13 - LONG $0xffd0850f; WORD $0xffff // jne LBB19_90, $-48(%rip) - WORD $0x894c; BYTE $0xe8 // movq %r13, %rax + WORD $0x568d; BYTE $0xd0 // leal $-48(%rsi), %edx + WORD $0xfa80; BYTE $0x0a // cmpb $10, %dl + LONG $0xffcc820f; WORD $0xffff // jb LBB15_95, $-52(%rip) + LONG $0x00000ae9; BYTE $0x00 // jmp LBB15_100, $10(%rip) -LBB19_93: - LONG $0xf0af0f41 // imull %r8d, %esi - WORD $0xce01 // addl %ecx, %esi - WORD $0x8949; BYTE $0xc5 // movq %rax, %r13 - LONG $0xfffd81e9; BYTE $0xff // jmp LBB19_60, $-639(%rip) - QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 +LBB15_98: + WORD $0xff31 // xorl %edi, %edi + LONG $0x000003e9; BYTE $0x00 // jmp LBB15_100, $3(%rip) + +LBB15_99: + WORD $0x894c; BYTE $0xe8 // movq %r13, %rax + +LBB15_100: + WORD $0x8948; BYTE $0xfe // movq %rdi, %rsi + LONG $0xf0af0f41 // imull %r8d, %esi + WORD $0xce01 // addl %ecx, %esi + WORD $0x8949; BYTE $0xc5 // movq %rax, %r13 + LONG $0xfffd3fe9; BYTE $0xff // jmp LBB15_62, $-705(%rip) + WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 _vsigned: BYTE $0x55 // pushq %rbp @@ -6283,71 +5807,72 @@ _vsigned: WORD $0x8b48; BYTE $0x0e // movq (%rsi), %rcx LONG $0x184a8948 // movq %rcx, $24(%rdx) WORD $0x394c; BYTE $0xd8 // cmpq %r11, %rax - LONG $0x0046830f; WORD $0x0000 // jae LBB20_1, $70(%rip) - LONG $0x0cb60f41; BYTE $0x01 // movzbl (%r9,%rax), %ecx + LONG $0x0044830f; WORD $0x0000 // jae LBB16_1, $68(%rip) + LONG $0x010c8a41 // movb (%r9,%rax), %cl LONG $0x0001b841; WORD $0x0000 // movl $1, %r8d WORD $0xf980; BYTE $0x2d // cmpb $45, %cl - LONG $0x0018850f; WORD $0x0000 // jne LBB20_5, $24(%rip) + LONG $0x0017850f; WORD $0x0000 // jne LBB16_5, $23(%rip) WORD $0xff48; BYTE $0xc0 // incq %rax WORD $0x394c; BYTE $0xd8 // cmpq %r11, %rax - LONG $0x0026830f; WORD $0x0000 // jae LBB20_1, $38(%rip) - LONG $0x0cb60f41; BYTE $0x01 // movzbl (%r9,%rax), %ecx + LONG $0x0025830f; WORD $0x0000 // jae LBB16_1, $37(%rip) + LONG $0x010c8a41 // movb (%r9,%rax), %cl LONG $0xffc0c749; WORD $0xffff; BYTE $0xff // movq $-1, %r8 -LBB20_5: - WORD $0x798d; BYTE $0xc6 // leal $-58(%rcx), %edi - LONG $0xf5ff8040 // cmpb $-11, %dil - LONG $0x001a870f; WORD $0x0000 // ja LBB20_7, $26(%rip) +LBB16_5: + WORD $0x798d; BYTE $0xd0 // leal $-48(%rcx), %edi + LONG $0x0aff8040 // cmpb $10, %dil + LONG $0x001a820f; WORD $0x0000 // jb LBB16_7, $26(%rip) WORD $0x8948; BYTE $0x06 // movq %rax, (%rsi) LONG $0xfe02c748; WORD $0xffff; BYTE $0xff // movq $-2, (%rdx) BYTE $0x5b // popq %rbx BYTE $0x5d // popq %rbp BYTE $0xc3 // retq -LBB20_1: +LBB16_1: WORD $0x894c; BYTE $0x1e // movq %r11, (%rsi) LONG $0xff02c748; WORD $0xffff; BYTE $0xff // movq $-1, (%rdx) BYTE $0x5b // popq %rbx BYTE $0x5d // popq %rbp BYTE $0xc3 // retq -LBB20_7: +LBB16_7: WORD $0xf980; BYTE $0x30 // cmpb $48, %cl - LONG $0x0032850f; WORD $0x0000 // jne LBB20_12, $50(%rip) - LONG $0x01508d4c // leaq $1(%rax), %r10 + LONG $0x0035850f; WORD $0x0000 // jne LBB16_12, $53(%rip) + LONG $0x01788d48 // leaq $1(%rax), %rdi WORD $0x394c; BYTE $0xd8 // cmpq %r11, %rax - LONG $0x007f830f; WORD $0x0000 // jae LBB20_11, $127(%rip) - LONG $0x3cb60f43; BYTE $0x11 // movzbl (%r9,%r10), %edi - WORD $0xc783; BYTE $0xd2 // addl $-46, %edi - WORD $0xff83; BYTE $0x37 // cmpl $55, %edi - LONG $0x006e870f; WORD $0x0000 // ja LBB20_11, $110(%rip) + LONG $0x0081830f; WORD $0x0000 // jae LBB16_11, $129(%rip) + LONG $0x390c8a41 // movb (%r9,%rdi), %cl + WORD $0xc180; BYTE $0xd2 // addb $-46, %cl + WORD $0xf980; BYTE $0x37 // cmpb $55, %cl + LONG $0x0071870f; WORD $0x0000 // ja LBB16_11, $113(%rip) + LONG $0xd1b60f44 // movzbl %cl, %r10d QUAD $0x000000800001b948; WORD $0x0080 // movabsq $36028797027352577, %rcx - LONG $0xf9a30f48 // btq %rdi, %rcx - LONG $0x005a830f; WORD $0x0000 // jae LBB20_11, $90(%rip) - -LBB20_12: - WORD $0x394c; BYTE $0xd8 // cmpq %r11, %rax - WORD $0x894d; BYTE $0xda // movq %r11, %r10 - LONG $0xd0470f4c // cmovaq %rax, %r10 - WORD $0xc931 // xorl %ecx, %ecx - LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + LONG $0xd1a30f4c // btq %r10, %rcx + LONG $0x0059830f; WORD $0x0000 // jae LBB16_11, $89(%rip) -LBB20_13: +LBB16_12: WORD $0x394c; BYTE $0xd8 // cmpq %r11, %rax - LONG $0x007d830f; WORD $0x0000 // jae LBB20_23, $125(%rip) + WORD $0x894d; BYTE $0xda // movq %r11, %r10 + LONG $0xd0470f4c // cmovaq %rax, %r10 + WORD $0xc931 // xorl %ecx, %ecx + LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 + +LBB16_13: + WORD $0x3949; BYTE $0xc2 // cmpq %rax, %r10 + LONG $0x007f840f; WORD $0x0000 // je LBB16_23, $127(%rip) LONG $0x3cbe0f49; BYTE $0x01 // movsbq (%r9,%rax), %rdi WORD $0x5f8d; BYTE $0xd0 // leal $-48(%rdi), %ebx WORD $0xfb80; BYTE $0x09 // cmpb $9, %bl - LONG $0x0033870f; WORD $0x0000 // ja LBB20_18, $51(%rip) + LONG $0x0033870f; WORD $0x0000 // ja LBB16_18, $51(%rip) LONG $0x0ac96b48 // imulq $10, %rcx, %rcx - LONG $0x0013800f; WORD $0x0000 // jo LBB20_17, $19(%rip) + LONG $0x0013800f; WORD $0x0000 // jo LBB16_17, $19(%rip) WORD $0xff48; BYTE $0xc0 // incq %rax WORD $0xc783; BYTE $0xd0 // addl $-48, %edi LONG $0xf8af0f49 // imulq %r8, %rdi WORD $0x0148; BYTE $0xf9 // addq %rdi, %rcx - LONG $0xffc9810f; WORD $0xffff // jno LBB20_13, $-55(%rip) + LONG $0xffc9810f; WORD $0xffff // jno LBB16_13, $-55(%rip) -LBB20_17: +LBB16_17: WORD $0xff48; BYTE $0xc8 // decq %rax WORD $0x8948; BYTE $0x06 // movq %rax, (%rsi) LONG $0xfb02c748; WORD $0xffff; BYTE $0xff // movq $-5, (%rdx) @@ -6355,169 +5880,160 @@ LBB20_17: BYTE $0x5d // popq %rbp BYTE $0xc3 // retq -LBB20_11: - WORD $0x894c; BYTE $0x16 // movq %r10, (%rsi) +LBB16_11: + WORD $0x8948; BYTE $0x3e // movq %rdi, (%rsi) BYTE $0x5b // popq %rbx BYTE $0x5d // popq %rbp BYTE $0xc3 // retq -LBB20_18: +LBB16_18: WORD $0x394c; BYTE $0xd8 // cmpq %r11, %rax - LONG $0x002d830f; WORD $0x0000 // jae LBB20_22, $45(%rip) - LONG $0x3cb60f41; BYTE $0x01 // movzbl (%r9,%rax), %edi - WORD $0xff83; BYTE $0x2e // cmpl $46, %edi - LONG $0x0012840f; WORD $0x0000 // je LBB20_25, $18(%rip) - WORD $0xff83; BYTE $0x45 // cmpl $69, %edi - LONG $0x0009840f; WORD $0x0000 // je LBB20_25, $9(%rip) - WORD $0xff83; BYTE $0x65 // cmpl $101, %edi - LONG $0x000d850f; WORD $0x0000 // jne LBB20_22, $13(%rip) - -LBB20_25: + LONG $0x002f830f; WORD $0x0000 // jae LBB16_22, $47(%rip) + LONG $0x013c8a41 // movb (%r9,%rax), %dil + LONG $0x2eff8040 // cmpb $46, %dil + LONG $0x0014840f; WORD $0x0000 // je LBB16_25, $20(%rip) + LONG $0x45ff8040 // cmpb $69, %dil + LONG $0x000a840f; WORD $0x0000 // je LBB16_25, $10(%rip) + LONG $0x65ff8040 // cmpb $101, %dil + LONG $0x000d850f; WORD $0x0000 // jne LBB16_22, $13(%rip) + +LBB16_25: WORD $0x8948; BYTE $0x06 // movq %rax, (%rsi) LONG $0xfa02c748; WORD $0xffff; BYTE $0xff // movq $-6, (%rdx) BYTE $0x5b // popq %rbx BYTE $0x5d // popq %rbp BYTE $0xc3 // retq -LBB20_22: +LBB16_22: WORD $0x8949; BYTE $0xc2 // movq %rax, %r10 -LBB20_23: - WORD $0x894c; BYTE $0x16 // movq %r10, (%rsi) - LONG $0x104a8948 // movq %rcx, $16(%rdx) - BYTE $0x5b // popq %rbx - BYTE $0x5d // popq %rbp - BYTE $0xc3 // retq +LBB16_23: + WORD $0x894c; BYTE $0x16 // movq %r10, (%rsi) + LONG $0x104a8948 // movq %rcx, $16(%rdx) + BYTE $0x5b // popq %rbx + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 - // .p2align 4, 0x90 _vunsigned: BYTE $0x55 // pushq %rbp WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp - WORD $0x5641 // pushq %r14 BYTE $0x53 // pushq %rbx WORD $0x8949; BYTE $0xd0 // movq %rdx, %r8 WORD $0x8b48; BYTE $0x0e // movq (%rsi), %rcx WORD $0x8b4c; BYTE $0x0f // movq (%rdi), %r9 - LONG $0x08778b4c // movq $8(%rdi), %r14 + LONG $0x085f8b4c // movq $8(%rdi), %r11 LONG $0x0902c748; WORD $0x0000; BYTE $0x00 // movq $9, (%rdx) LONG $0xc057f8c5 // vxorps %xmm0, %xmm0, %xmm0 LONG $0x4211f8c5; BYTE $0x08 // vmovups %xmm0, $8(%rdx) WORD $0x8b48; BYTE $0x06 // movq (%rsi), %rax LONG $0x18428948 // movq %rax, $24(%rdx) - WORD $0x394c; BYTE $0xf1 // cmpq %r14, %rcx - LONG $0x001c830f; WORD $0x0000 // jae LBB21_1, $28(%rip) - LONG $0x04b60f41; BYTE $0x09 // movzbl (%r9,%rcx), %eax + WORD $0x394c; BYTE $0xd9 // cmpq %r11, %rcx + LONG $0x0019830f; WORD $0x0000 // jae LBB17_1, $25(%rip) + LONG $0x09048a41 // movb (%r9,%rcx), %al WORD $0x2d3c // cmpb $45, %al - LONG $0x001e850f; WORD $0x0000 // jne LBB21_4, $30(%rip) + LONG $0x001a850f; WORD $0x0000 // jne LBB17_4, $26(%rip) -LBB21_3: +LBB17_3: WORD $0x8948; BYTE $0x0e // movq %rcx, (%rsi) LONG $0xfa00c749; WORD $0xffff; BYTE $0xff // movq $-6, (%r8) BYTE $0x5b // popq %rbx - WORD $0x5e41 // popq %r14 BYTE $0x5d // popq %rbp BYTE $0xc3 // retq -LBB21_1: - WORD $0x894c; BYTE $0x36 // movq %r14, (%rsi) +LBB17_1: + WORD $0x894c; BYTE $0x1e // movq %r11, (%rsi) LONG $0xff00c749; WORD $0xffff; BYTE $0xff // movq $-1, (%r8) BYTE $0x5b // popq %rbx - WORD $0x5e41 // popq %r14 BYTE $0x5d // popq %rbp BYTE $0xc3 // retq -LBB21_4: - WORD $0x508d; BYTE $0xc6 // leal $-58(%rax), %edx - WORD $0xfa80; BYTE $0xf5 // cmpb $-11, %dl - LONG $0x000f870f; WORD $0x0000 // ja LBB21_6, $15(%rip) +LBB17_4: + WORD $0x508d; BYTE $0xd0 // leal $-48(%rax), %edx + WORD $0xfa80; BYTE $0x0a // cmpb $10, %dl + LONG $0x000d820f; WORD $0x0000 // jb LBB17_6, $13(%rip) WORD $0x8948; BYTE $0x0e // movq %rcx, (%rsi) LONG $0xfe00c749; WORD $0xffff; BYTE $0xff // movq $-2, (%r8) BYTE $0x5b // popq %rbx - WORD $0x5e41 // popq %r14 BYTE $0x5d // popq %rbp BYTE $0xc3 // retq -LBB21_6: +LBB17_6: WORD $0x303c // cmpb $48, %al - LONG $0x0026850f; WORD $0x0000 // jne LBB21_10, $38(%rip) - LONG $0x44b60f41; WORD $0x0109 // movzbl $1(%r9,%rcx), %eax - WORD $0xc083; BYTE $0xd2 // addl $-46, %eax - WORD $0xf883; BYTE $0x37 // cmpl $55, %eax - LONG $0x00c0870f; WORD $0x0000 // ja LBB21_9, $192(%rip) + LONG $0x0026850f; WORD $0x0000 // jne LBB17_7, $38(%rip) + LONG $0x09448a41; BYTE $0x01 // movb $1(%r9,%rcx), %al + WORD $0xd204 // addb $-46, %al + WORD $0x373c // cmpb $55, %al + LONG $0x00b6870f; WORD $0x0000 // ja LBB17_16, $182(%rip) + WORD $0xb60f; BYTE $0xc0 // movzbl %al, %eax QUAD $0x000000800001ba48; WORD $0x0080 // movabsq $36028797027352577, %rdx LONG $0xc2a30f48 // btq %rax, %rdx - LONG $0x00ac830f; WORD $0x0000 // jae LBB21_9, $172(%rip) + LONG $0x009f830f; WORD $0x0000 // jae LBB17_16, $159(%rip) -LBB21_10: - WORD $0x3949; BYTE $0xce // cmpq %rcx, %r14 - WORD $0x8949; BYTE $0xca // movq %rcx, %r10 - LONG $0xd6470f4d // cmovaq %r14, %r10 - WORD $0xc031 // xorl %eax, %eax - LONG $0x000abb41; WORD $0x0000 // movl $10, %r11d - LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 +LBB17_7: + WORD $0xc031 // xorl %eax, %eax + LONG $0x000aba41; WORD $0x0000 // movl $10, %r10d + QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90 -LBB21_11: - WORD $0x394c; BYTE $0xf1 // cmpq %r14, %rcx - LONG $0x007f830f; WORD $0x0000 // jae LBB21_22, $127(%rip) - LONG $0x1cbe0f41; BYTE $0x09 // movsbl (%r9,%rcx), %ebx - WORD $0x538d; BYTE $0xd0 // leal $-48(%rbx), %edx +LBB17_8: + WORD $0x3949; BYTE $0xcb // cmpq %rcx, %r11 + LONG $0x007b840f; WORD $0x0000 // je LBB17_22, $123(%rip) + LONG $0x3cbe0f41; BYTE $0x09 // movsbl (%r9,%rcx), %edi + WORD $0x578d; BYTE $0xd0 // leal $-48(%rdi), %edx WORD $0xfa80; BYTE $0x09 // cmpb $9, %dl - LONG $0x0042870f; WORD $0x0000 // ja LBB21_17, $66(%rip) - WORD $0xf749; BYTE $0xe3 // mulq %r11 - LONG $0x0027800f; WORD $0x0000 // jo LBB21_16, $39(%rip) + LONG $0x003f870f; WORD $0x0000 // ja LBB17_17, $63(%rip) + WORD $0xf749; BYTE $0xe2 // mulq %r10 + LONG $0x0026800f; WORD $0x0000 // jo LBB17_13, $38(%rip) WORD $0xff48; BYTE $0xc1 // incq %rcx - WORD $0xc383; BYTE $0xd0 // addl $-48, %ebx - WORD $0xff31 // xorl %edi, %edi - WORD $0x0148; BYTE $0xd8 // addq %rbx, %rax - LONG $0xc7920f40 // setb %dil - WORD $0x8948; BYTE $0xfa // movq %rdi, %rdx + WORD $0xc783; BYTE $0xd0 // addl $-48, %edi + WORD $0xdb31 // xorl %ebx, %ebx + WORD $0x0148; BYTE $0xf8 // addq %rdi, %rax + WORD $0x920f; BYTE $0xc3 // setb %bl + WORD $0x8948; BYTE $0xda // movq %rbx, %rdx WORD $0xf748; BYTE $0xda // negq %rdx - WORD $0x3148; BYTE $0xd7 // xorq %rdx, %rdi - LONG $0x0009850f; WORD $0x0000 // jne LBB21_16, $9(%rip) + WORD $0x3148; BYTE $0xd3 // xorq %rdx, %rbx + LONG $0x0009850f; WORD $0x0000 // jne LBB17_13, $9(%rip) WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx - LONG $0xffb6890f; WORD $0xffff // jns LBB21_11, $-74(%rip) + LONG $0xffb7890f; WORD $0xffff // jns LBB17_8, $-73(%rip) -LBB21_16: +LBB17_13: WORD $0xff48; BYTE $0xc9 // decq %rcx WORD $0x8948; BYTE $0x0e // movq %rcx, (%rsi) LONG $0xfb00c749; WORD $0xffff; BYTE $0xff // movq $-5, (%r8) BYTE $0x5b // popq %rbx - WORD $0x5e41 // popq %r14 BYTE $0x5d // popq %rbp BYTE $0xc3 // retq -LBB21_17: - WORD $0x394c; BYTE $0xf1 // cmpq %r14, %rcx - LONG $0x0020830f; WORD $0x0000 // jae LBB21_21, $32(%rip) - LONG $0x14b60f41; BYTE $0x09 // movzbl (%r9,%rcx), %edx - WORD $0xfa83; BYTE $0x2e // cmpl $46, %edx - LONG $0xff0e840f; WORD $0xffff // je LBB21_3, $-242(%rip) - WORD $0xfa83; BYTE $0x45 // cmpl $69, %edx - LONG $0xff05840f; WORD $0xffff // je LBB21_3, $-251(%rip) - WORD $0xfa83; BYTE $0x65 // cmpl $101, %edx - LONG $0xfefc840f; WORD $0xffff // je LBB21_3, $-260(%rip) - -LBB21_21: - WORD $0x8949; BYTE $0xca // movq %rcx, %r10 - -LBB21_22: - WORD $0x894c; BYTE $0x16 // movq %r10, (%rsi) +LBB17_17: + WORD $0x394c; BYTE $0xd9 // cmpq %r11, %rcx + LONG $0x001f830f; WORD $0x0000 // jae LBB17_21, $31(%rip) + LONG $0x09148a41 // movb (%r9,%rcx), %dl + WORD $0xfa80; BYTE $0x2e // cmpb $46, %dl + LONG $0xff1f840f; WORD $0xffff // je LBB17_3, $-225(%rip) + WORD $0xfa80; BYTE $0x45 // cmpb $69, %dl + LONG $0xff16840f; WORD $0xffff // je LBB17_3, $-234(%rip) + WORD $0xfa80; BYTE $0x65 // cmpb $101, %dl + LONG $0xff0d840f; WORD $0xffff // je LBB17_3, $-243(%rip) + +LBB17_21: + WORD $0x8949; BYTE $0xcb // movq %rcx, %r11 + +LBB17_22: + WORD $0x894c; BYTE $0x1e // movq %r11, (%rsi) LONG $0x10408949 // movq %rax, $16(%r8) BYTE $0x5b // popq %rbx - WORD $0x5e41 // popq %r14 BYTE $0x5d // popq %rbp BYTE $0xc3 // retq -LBB21_9: - WORD $0xff48; BYTE $0xc1 // incq %rcx - WORD $0x8948; BYTE $0x0e // movq %rcx, (%rsi) - BYTE $0x5b // popq %rbx - WORD $0x5e41 // popq %r14 - BYTE $0x5d // popq %rbp - BYTE $0xc3 // retq - BYTE $0x00 // .p2align 4, 0x00 +LBB17_16: + WORD $0xff48; BYTE $0xc1 // incq %rcx + WORD $0x8948; BYTE $0x0e // movq %rcx, (%rsi) + BYTE $0x5b // popq %rbx + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + QUAD $0x0000000000000000; BYTE $0x00 // .p2align 4, 0x00 -LCPI22_0: +LCPI18_0: QUAD $0x0000000000000001 // .quad 1 QUAD $0x0000000000000005 // .quad 5 @@ -6528,7 +6044,7 @@ _skip_array: WORD $0x8948; BYTE $0xd0 // movq %rdx, %rax WORD $0x8948; BYTE $0xf2 // movq %rsi, %rdx WORD $0x8948; BYTE $0xfe // movq %rdi, %rsi - QUAD $0xffffffdb0528f8c5 // vmovaps $-37(%rip), %xmm0 /* LCPI22_0(%rip) */ + QUAD $0xffffffdb0528f8c5 // vmovaps $-37(%rip), %xmm0 /* LCPI18_0(%rip) */ LONG $0x0011f8c5 // vmovups %xmm0, (%rax) WORD $0x8948; BYTE $0xc7 // movq %rax, %rdi BYTE $0x5d // popq %rbp @@ -6543,324 +6059,328 @@ _fsm_exec: WORD $0x5541 // pushq %r13 WORD $0x5441 // pushq %r12 BYTE $0x53 // pushq %rbx - LONG $0x18ec8348 // subq $24, %rsp - LONG $0xc04d8948 // movq %rcx, $-64(%rbp) + LONG $0x28ec8348 // subq $40, %rsp + LONG $0xb84d8948 // movq %rcx, $-72(%rbp) LONG $0x003f8348 // cmpq $0, (%rdi) - LONG $0x03f4840f; WORD $0x0000 // je LBB23_2, $1012(%rip) - WORD $0x8948; BYTE $0xd3 // movq %rdx, %rbx - WORD $0x8949; BYTE $0xf6 // movq %rsi, %r14 - WORD $0x8949; BYTE $0xff // movq %rdi, %r15 - LONG $0xffc4c749; WORD $0xffff; BYTE $0xff // movq $-1, %r12 + LONG $0x0407840f; WORD $0x0000 // je LBB19_2, $1031(%rip) + WORD $0x8949; BYTE $0xd0 // movq %rdx, %r8 + WORD $0x8949; BYTE $0xfd // movq %rdi, %r13 LONG $0xc8758948 // movq %rsi, $-56(%rbp) - LONG $0x000034e9; BYTE $0x00 // jmp LBB23_7, $52(%rip) - -LBB23_3: - WORD $0x8b49; BYTE $0x0f // movq (%r15), %rcx - LONG $0x000006b8; BYTE $0x00 // movl $6, %eax - LONG $0xfff98148; WORD $0x000f; BYTE $0x00 // cmpq $4095, %rcx - LONG $0x03df8f0f; WORD $0x0000 // jg LBB23_65, $991(%rip) - WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 - -LBB23_4: - LONG $0x01518d48 // leaq $1(%rcx), %rdx - WORD $0x8949; BYTE $0x17 // movq %rdx, (%r15) - WORD $0x8948; BYTE $0xca // movq %rcx, %rdx + LONG $0x08468d48 // leaq $8(%rsi), %rax + LONG $0xc0458948 // movq %rax, $-64(%rbp) + LONG $0xffc4c749; WORD $0xffff; BYTE $0xff // movq $-1, %r12 + LONG $0x000023e9; BYTE $0x00 // jmp LBB19_4, $35(%rip) -LBB23_5: - LONG $0xd7448949; BYTE $0x08 // movq %rax, $8(%r15,%rdx,8) +LBB19_3: + LONG $0x03488d48 // leaq $3(%rax), %rcx + WORD $0x8949; BYTE $0x08 // movq %rcx, (%r8) + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0x04498e0f; WORD $0x0000 // jle LBB19_62, $1097(%rip) + WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 -LBB23_6: - LONG $0x003f8349 // cmpq $0, (%r15) - WORD $0x894c; BYTE $0xe0 // movq %r12, %rax - LONG $0x03f7840f; WORD $0x0000 // je LBB23_56, $1015(%rip) +LBB19_39: + LONG $0x00558b49 // movq (%r13), %rdx + WORD $0x894d; BYTE $0xe6 // movq %r12, %r14 + WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx + LONG $0x0415840f; WORD $0x0000 // je LBB19_65, $1045(%rip) -LBB23_7: - WORD $0x894c; BYTE $0xf7 // movq %r14, %rdi - WORD $0x8948; BYTE $0xde // movq %rbx, %rsi - LONG $0xffee69e8; BYTE $0xff // callq _advance_ns, $-4503(%rip) +LBB19_4: + LONG $0xc8758b4c // movq $-56(%rbp), %r14 + WORD $0x8b49; BYTE $0x3e // movq (%r14), %rdi + LONG $0x08768b49 // movq $8(%r14), %rsi + WORD $0x894c; BYTE $0xc3 // movq %r8, %rbx + WORD $0x894c; BYTE $0xc2 // movq %r8, %rdx + LONG $0xffef4ae8; BYTE $0xff // callq _advance_ns, $-4278(%rip) WORD $0xc084 // testb %al, %al - LONG $0x0394840f; WORD $0x0000 // je LBB23_2, $916(%rip) + LONG $0x03a8840f; WORD $0x0000 // je LBB19_2, $936(%rip) + LONG $0x004d8b49 // movq (%r13), %rcx + LONG $0xcd7c8b41; BYTE $0x00 // movl (%r13,%rcx,8), %edi LONG $0xfffc8349 // cmpq $-1, %r12 - LONG $0x0006850f; WORD $0x0000 // jne LBB23_10, $6(%rip) - WORD $0x8b4c; BYTE $0x23 // movq (%rbx), %r12 + WORD $0x8949; BYTE $0xd8 // movq %rbx, %r8 + LONG $0x0006850f; WORD $0x0000 // jne LBB19_7, $6(%rip) + WORD $0x8b4d; BYTE $0x20 // movq (%r8), %r12 WORD $0xff49; BYTE $0xcc // decq %r12 -LBB23_10: +LBB19_7: WORD $0xbe0f; BYTE $0xf0 // movsbl %al, %esi - WORD $0x8b49; BYTE $0x0f // movq (%r15), %rcx LONG $0xff518d48 // leaq $-1(%rcx), %rdx - LONG $0xcf3c8b41 // movl (%r15,%rcx,8), %edi WORD $0xcfff // decl %edi WORD $0xff83; BYTE $0x05 // cmpl $5, %edi - LONG $0x0036870f; WORD $0x0000 // ja LBB23_14, $54(%rip) - WORD $0x894d; BYTE $0xf0 // movq %r14, %r8 - WORD $0x894d; BYTE $0xe6 // movq %r12, %r14 - WORD $0x8949; BYTE $0xdc // movq %rbx, %r12 - LONG $0xc41d8d48; WORD $0x0004; BYTE $0x00 // leaq $1220(%rip), %rbx /* LJTI23_0(%rip) */ + LONG $0x0037870f; WORD $0x0000 // ja LBB19_12, $55(%rip) + LONG $0xf91d8d48; WORD $0x0004; BYTE $0x00 // leaq $1273(%rip), %rbx /* LJTI19_0(%rip) */ LONG $0xbb3c6348 // movslq (%rbx,%rdi,4), %rdi WORD $0x0148; BYTE $0xdf // addq %rbx, %rdi JMP DI -LBB23_12: +LBB19_9: WORD $0xfe83; BYTE $0x2c // cmpl $44, %esi - WORD $0x894c; BYTE $0xe3 // movq %r12, %rbx - LONG $0x019a840f; WORD $0x0000 // je LBB23_33, $410(%rip) + LONG $0x0173840f; WORD $0x0000 // je LBB19_31, $371(%rip) WORD $0xfe83; BYTE $0x5d // cmpl $93, %esi - WORD $0x894d; BYTE $0xf4 // movq %r14, %r12 - LONG $0x0177840f; WORD $0x0000 // je LBB23_32, $375(%rip) - LONG $0x000367e9; BYTE $0x00 // jmp LBB23_61, $871(%rip) + LONG $0x03a0850f; WORD $0x0000 // jne LBB19_64, $928(%rip) + LONG $0x00558949 // movq %rdx, (%r13) + WORD $0x894d; BYTE $0xe6 // movq %r12, %r14 + WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx + LONG $0xff82850f; WORD $0xffff // jne LBB19_4, $-126(%rip) + LONG $0x000392e9; BYTE $0x00 // jmp LBB19_65, $914(%rip) -LBB23_14: - WORD $0x8949; BYTE $0x17 // movq %rdx, (%r15) - LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq $-2, %rax - WORD $0xfe83; BYTE $0x7b // cmpl $123, %esi - LONG $0x00b4860f; WORD $0x0000 // jbe LBB23_25, $180(%rip) - LONG $0x00036de9; BYTE $0x00 // jmp LBB23_56, $877(%rip) +LBB19_12: + LONG $0x00558949 // movq %rdx, (%r13) + WORD $0xfe83; BYTE $0x7b // cmpl $123, %esi + LONG $0x00ea860f; WORD $0x0000 // jbe LBB19_28, $234(%rip) + LONG $0x000379e9; BYTE $0x00 // jmp LBB19_64, $889(%rip) -LBB23_15: - WORD $0xfe83; BYTE $0x7d // cmpl $125, %esi - WORD $0x894c; BYTE $0xe3 // movq %r12, %rbx - WORD $0x894d; BYTE $0xf4 // movq %r14, %r12 - LONG $0x014b840f; WORD $0x0000 // je LBB23_32, $331(%rip) - WORD $0xfe83; BYTE $0x2c // cmpl $44, %esi - LONG $0x0337850f; WORD $0x0000 // jne LBB23_61, $823(%rip) - LONG $0x000003b8; BYTE $0x00 // movl $3, %eax - LONG $0xfff98148; WORD $0x000f; BYTE $0x00 // cmpq $4095, %rcx - WORD $0x894d; BYTE $0xc6 // movq %r8, %r14 - LONG $0xff2d8e0f; WORD $0xffff // jle LBB23_4, $-211(%rip) - LONG $0x000304e9; BYTE $0x00 // jmp LBB23_65, $772(%rip) +LBB19_13: + WORD $0xfe83; BYTE $0x2c // cmpl $44, %esi + LONG $0x015d840f; WORD $0x0000 // je LBB19_33, $349(%rip) + WORD $0xfe83; BYTE $0x7d // cmpl $125, %esi + LONG $0x0367850f; WORD $0x0000 // jne LBB19_64, $871(%rip) + LONG $0x00558949 // movq %rdx, (%r13) + WORD $0x894d; BYTE $0xe6 // movq %r12, %r14 + WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx + LONG $0xff49850f; WORD $0xffff // jne LBB19_4, $-183(%rip) + LONG $0x000359e9; BYTE $0x00 // jmp LBB19_65, $857(%rip) -LBB23_18: - WORD $0x223c // cmpb $34, %al - LONG $0x0315850f; WORD $0x0000 // jne LBB23_61, $789(%rip) - QUAD $0x00000004cf04c749 // movq $4, (%r15,%rcx,8) - WORD $0x894c; BYTE $0xc7 // movq %r8, %rdi - LONG $0x241c8b49 // movq (%r12), %rbx - WORD $0x8948; BYTE $0xde // movq %rbx, %rsi +LBB19_16: + WORD $0x223c // cmpb $34, %al + LONG $0x034a850f; WORD $0x0000 // jne LBB19_64, $842(%rip) + QUAD $0x00000400cd44c749; BYTE $0x00 // movq $4, (%r13,%rcx,8) + QUAD $0xffffffffd045c748 // movq $-1, $-48(%rbp) + WORD $0x8b4d; BYTE $0x38 // movq (%r8), %r15 + WORD $0x894c; BYTE $0xf7 // movq %r14, %rdi + +LBB19_18: + WORD $0x894c; BYTE $0xfe // movq %r15, %rsi LONG $0xd0558d48 // leaq $-48(%rbp), %rdx - LONG $0xc04d8b48 // movq $-64(%rbp), %rcx - LONG $0xfff191e8; BYTE $0xff // callq _advance_string, $-3695(%rip) - WORD $0x8949; BYTE $0xc5 // movq %rax, %r13 + LONG $0xb84d8b48 // movq $-72(%rbp), %rcx + WORD $0x894c; BYTE $0xc3 // movq %r8, %rbx + LONG $0xfff112e8; BYTE $0xff // callq _advance_string, $-3822(%rip) + WORD $0x8949; BYTE $0xc6 // movq %rax, %r14 WORD $0x8548; BYTE $0xc0 // testq %rax, %rax - LONG $0x0126890f; WORD $0x0000 // jns LBB23_35, $294(%rip) - LONG $0xd0458b48 // movq $-48(%rbp), %rax - LONG $0x000126e9; BYTE $0x00 // jmp LBB23_36, $294(%rip) + LONG $0x02e4880f; WORD $0x0000 // js LBB19_55, $740(%rip) + WORD $0x894c; BYTE $0x33 // movq %r14, (%rbx) + WORD $0x854d; BYTE $0xff // testq %r15, %r15 + WORD $0x8949; BYTE $0xd8 // movq %rbx, %r8 + LONG $0xfee78f0f; WORD $0xffff // jg LBB19_39, $-281(%rip) + LONG $0x0002e8e9; BYTE $0x00 // jmp LBB19_56, $744(%rip) + +LBB19_20: + WORD $0x3a3c // cmpb $58, %al + LONG $0x02f8850f; WORD $0x0000 // jne LBB19_64, $760(%rip) + QUAD $0x00000000cd44c749; BYTE $0x00 // movq $0, (%r13,%rcx,8) + LONG $0xfffecce9; BYTE $0xff // jmp LBB19_39, $-308(%rip) + +LBB19_22: + WORD $0x5d3c // cmpb $93, %al + LONG $0x003c850f; WORD $0x0000 // jne LBB19_27, $60(%rip) + LONG $0x00558949 // movq %rdx, (%r13) + WORD $0x894d; BYTE $0xe6 // movq %r12, %r14 + WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx + LONG $0xfec4850f; WORD $0xffff // jne LBB19_4, $-316(%rip) + LONG $0x0002d4e9; BYTE $0x00 // jmp LBB19_65, $724(%rip) -LBB23_21: - WORD $0x3a3c // cmpb $58, %al - LONG $0x02d9850f; WORD $0x0000 // jne LBB23_61, $729(%rip) - WORD $0x894c; BYTE $0xe3 // movq %r12, %rbx - WORD $0xc031 // xorl %eax, %eax - WORD $0x894d; BYTE $0xf4 // movq %r14, %r12 - WORD $0x894d; BYTE $0xc6 // movq %r8, %r14 - LONG $0xfffedee9; BYTE $0xff // jmp LBB23_5, $-290(%rip) +LBB19_24: + WORD $0xfe83; BYTE $0x22 // cmpl $34, %esi + LONG $0x00d4840f; WORD $0x0000 // je LBB19_35, $212(%rip) + WORD $0xfe83; BYTE $0x7d // cmpl $125, %esi + LONG $0x02bb850f; WORD $0x0000 // jne LBB19_64, $699(%rip) + LONG $0x00558949 // movq %rdx, (%r13) + WORD $0x894d; BYTE $0xe6 // movq %r12, %r14 + WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx + LONG $0xfe9d850f; WORD $0xffff // jne LBB19_4, $-355(%rip) + LONG $0x0002ade9; BYTE $0x00 // jmp LBB19_65, $685(%rip) -LBB23_23: - WORD $0x5d3c // cmpb $93, %al - WORD $0x894c; BYTE $0xe3 // movq %r12, %rbx - WORD $0x894d; BYTE $0xf4 // movq %r14, %r12 - LONG $0x00c6840f; WORD $0x0000 // je LBB23_32, $198(%rip) - QUAD $0x00000001cf04c749 // movq $1, (%r15,%rcx,8) - WORD $0x894d; BYTE $0xc6 // movq %r8, %r14 - LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq $-2, %rax - WORD $0xfe83; BYTE $0x7b // cmpl $123, %esi - LONG $0x02be870f; WORD $0x0000 // ja LBB23_56, $702(%rip) +LBB19_27: + QUAD $0x00000100cd44c749; BYTE $0x00 // movq $1, (%r13,%rcx,8) + WORD $0xfe83; BYTE $0x7b // cmpl $123, %esi + LONG $0x0294870f; WORD $0x0000 // ja LBB19_64, $660(%rip) -LBB23_25: - WORD $0xf189 // movl %esi, %ecx - LONG $0xe6158d48; WORD $0x0003; BYTE $0x00 // leaq $998(%rip), %rdx /* LJTI23_1(%rip) */ - LONG $0x8a0c6348 // movslq (%rdx,%rcx,4), %rcx - WORD $0x0148; BYTE $0xd1 // addq %rdx, %rcx - LONG $0xffc5c749; WORD $0xffff; BYTE $0xff // movq $-1, %r13 - JMP CX +LBB19_28: + WORD $0xf089 // movl %esi, %eax + LONG $0xe10d8d48; WORD $0x0003; BYTE $0x00 // leaq $993(%rip), %rcx /* LJTI19_1(%rip) */ + LONG $0x81046348 // movslq (%rcx,%rax,4), %rax + WORD $0x0148; BYTE $0xc8 // addq %rcx, %rax + LONG $0xffc6c749; WORD $0xffff; BYTE $0xff // movq $-1, %r14 + JMP AX -LBB23_26: - WORD $0x894c; BYTE $0xf0 // movq %r14, %rax - WORD $0x8b4c; BYTE $0x33 // movq (%rbx), %r14 - LONG $0xff6e8d4d // leaq $-1(%r14), %r13 +LBB19_29: + WORD $0x894c; BYTE $0xc3 // movq %r8, %rbx + WORD $0x8b4d; BYTE $0x38 // movq (%r8), %r15 + LONG $0xff778d4d // leaq $-1(%r15), %r14 + LONG $0xc8458b48 // movq $-56(%rbp), %rax WORD $0x8b48; BYTE $0x38 // movq (%rax), %rdi - WORD $0x014c; BYTE $0xef // addq %r13, %rdi + WORD $0x014c; BYTE $0xf7 // addq %r14, %rdi LONG $0x08708b48 // movq $8(%rax), %rsi - WORD $0x294c; BYTE $0xee // subq %r13, %rsi - LONG $0x0007f6e8; BYTE $0x00 // callq _do_skip_number, $2038(%rip) + WORD $0x294c; BYTE $0xf6 // subq %r14, %rsi + LONG $0x0007fde8; BYTE $0x00 // callq _do_skip_number, $2045(%rip) WORD $0x8548; BYTE $0xc0 // testq %rax, %rax - LONG $0x0255880f; WORD $0x0000 // js LBB23_60, $597(%rip) + LONG $0x0245880f; WORD $0x0000 // js LBB19_57, $581(%rip) WORD $0x8b48; BYTE $0x0b // movq (%rbx), %rcx - WORD $0x0148; BYTE $0xc8 // addq %rcx, %rax - WORD $0xff48; BYTE $0xc8 // decq %rax + LONG $0x08448d48; BYTE $0xff // leaq $-1(%rax,%rcx), %rax WORD $0x8948; BYTE $0x03 // movq %rax, (%rbx) - WORD $0x854d; BYTE $0xf6 // testq %r14, %r14 - LONG $0xc8758b4c // movq $-56(%rbp), %r14 - LONG $0xfe638f0f; WORD $0xffff // jg LBB23_6, $-413(%rip) - LONG $0x000219e9; BYTE $0x00 // jmp LBB23_57, $537(%rip) - -LBB23_28: - WORD $0xfe83; BYTE $0x7d // cmpl $125, %esi - WORD $0x894c; BYTE $0xe3 // movq %r12, %rbx - WORD $0x894d; BYTE $0xf4 // movq %r14, %r12 - LONG $0x0040840f; WORD $0x0000 // je LBB23_32, $64(%rip) - WORD $0xfe83; BYTE $0x22 // cmpl $34, %esi - LONG $0x022c850f; WORD $0x0000 // jne LBB23_61, $556(%rip) - QUAD $0x00000002cf04c749 // movq $2, (%r15,%rcx,8) - WORD $0x894c; BYTE $0xc7 // movq %r8, %rdi - WORD $0x8949; BYTE $0xde // movq %rbx, %r14 - WORD $0x8b4c; BYTE $0x33 // movq (%rbx), %r14 - WORD $0x894c; BYTE $0xf6 // movq %r14, %rsi - LONG $0xd0558d48 // leaq $-48(%rbp), %rdx - LONG $0xc04d8b48 // movq $-64(%rbp), %rcx - LONG $0xfff0a6e8; BYTE $0xff // callq _advance_string, $-3930(%rip) - WORD $0x8949; BYTE $0xc5 // movq %rax, %r13 - WORD $0x8548; BYTE $0xc0 // testq %rax, %rax - LONG $0x0063890f; WORD $0x0000 // jns LBB23_37, $99(%rip) - LONG $0xd0458b48 // movq $-48(%rbp), %rax - LONG $0x000063e9; BYTE $0x00 // jmp LBB23_38, $99(%rip) - BYTE $0x90 // .p2align 4, 0x90 - -LBB23_32: - WORD $0x8949; BYTE $0x17 // movq %rdx, (%r15) - WORD $0x894d; BYTE $0xe5 // movq %r12, %r13 - WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx - WORD $0x894d; BYTE $0xc6 // movq %r8, %r14 - LONG $0xfe0a850f; WORD $0xffff // jne LBB23_7, $-502(%rip) - LONG $0x0001b3e9; BYTE $0x00 // jmp LBB23_57, $435(%rip) + WORD $0x854d; BYTE $0xff // testq %r15, %r15 + WORD $0x8949; BYTE $0xd8 // movq %rbx, %r8 + LONG $0xfe1d8f0f; WORD $0xffff // jg LBB19_39, $-483(%rip) + LONG $0x00023de9; BYTE $0x00 // jmp LBB19_65, $573(%rip) -LBB23_33: +LBB19_31: LONG $0xfff98148; WORD $0x000f; BYTE $0x00 // cmpq $4095, %rcx - LONG $0x01b88f0f; WORD $0x0000 // jg LBB23_65, $440(%rip) - WORD $0x894d; BYTE $0xf4 // movq %r14, %r12 - WORD $0xc031 // xorl %eax, %eax - WORD $0x894d; BYTE $0xc6 // movq %r8, %r14 - LONG $0xfffdcfe9; BYTE $0xff // jmp LBB23_4, $-561(%rip) + LONG $0x01ed8f0f; WORD $0x0000 // jg LBB19_58, $493(%rip) + LONG $0x01418d48 // leaq $1(%rcx), %rax + LONG $0x00458949 // movq %rax, (%r13) + QUAD $0x00000008cd44c749; BYTE $0x00 // movq $0, $8(%r13,%rcx,8) + LONG $0xfffdf5e9; BYTE $0xff // jmp LBB19_39, $-523(%rip) -LBB23_35: - WORD $0xff48; BYTE $0xcb // decq %rbx - WORD $0x894c; BYTE $0xe8 // movq %r13, %rax - WORD $0x8949; BYTE $0xdd // movq %rbx, %r13 - -LBB23_36: - WORD $0x894c; BYTE $0xe3 // movq %r12, %rbx - LONG $0x24048949 // movq %rax, (%r12) - WORD $0x854d; BYTE $0xed // testq %r13, %r13 - LONG $0xc8458b48 // movq $-56(%rbp), %rax - WORD $0x894d; BYTE $0xf4 // movq %r14, %r12 - WORD $0x8949; BYTE $0xc6 // movq %rax, %r14 - LONG $0xfdbb890f; WORD $0xffff // jns LBB23_6, $-581(%rip) - LONG $0x000171e9; BYTE $0x00 // jmp LBB23_57, $369(%rip) - -LBB23_37: - WORD $0xff49; BYTE $0xce // decq %r14 - WORD $0x894c; BYTE $0xe8 // movq %r13, %rax - WORD $0x894d; BYTE $0xf5 // movq %r14, %r13 - -LBB23_38: - WORD $0x8948; BYTE $0x03 // movq %rax, (%rbx) - WORD $0x854d; BYTE $0xed // testq %r13, %r13 - LONG $0xc8758b4c // movq $-56(%rbp), %r14 - LONG $0x0158880f; WORD $0x0000 // js LBB23_57, $344(%rip) - WORD $0x8b49; BYTE $0x0f // movq (%r15), %rcx - LONG $0x000004b8; BYTE $0x00 // movl $4, %eax +LBB19_33: LONG $0xfff98148; WORD $0x000f; BYTE $0x00 // cmpq $4095, %rcx - LONG $0xfd798e0f; WORD $0xffff // jle LBB23_4, $-647(%rip) - LONG $0x000150e9; BYTE $0x00 // jmp LBB23_65, $336(%rip) - -LBB23_40: - WORD $0x894c; BYTE $0xf7 // movq %r14, %rdi - WORD $0x8949; BYTE $0xde // movq %rbx, %r14 - WORD $0x8b48; BYTE $0x1b // movq (%rbx), %rbx - WORD $0x8948; BYTE $0xde // movq %rbx, %rsi - LONG $0xd0558d48 // leaq $-48(%rbp), %rdx - LONG $0xc04d8b48 // movq $-64(%rbp), %rcx - LONG $0xffefebe8; BYTE $0xff // callq _advance_string, $-4117(%rip) - WORD $0x8949; BYTE $0xc5 // movq %rax, %r13 - WORD $0x8548; BYTE $0xc0 // testq %rax, %rax - LONG $0x00f1890f; WORD $0x0000 // jns LBB23_53, $241(%rip) - LONG $0xd0458b48 // movq $-48(%rbp), %rax - LONG $0x0000f1e9; BYTE $0x00 // jmp LBB23_54, $241(%rip) - -LBB23_42: - WORD $0x8b4c; BYTE $0x2b // movq (%rbx), %r13 - WORD $0x8b49; BYTE $0x3e // movq (%r14), %rdi - WORD $0x014c; BYTE $0xef // addq %r13, %rdi - LONG $0x08768b49 // movq $8(%r14), %rsi - WORD $0x294c; BYTE $0xee // subq %r13, %rsi - LONG $0x0006b1e8; BYTE $0x00 // callq _do_skip_number, $1713(%rip) + LONG $0x01ca8f0f; WORD $0x0000 // jg LBB19_58, $458(%rip) + LONG $0x01418d48 // leaq $1(%rcx), %rax + LONG $0x00458949 // movq %rax, (%r13) + QUAD $0x00000308cd44c749; BYTE $0x00 // movq $3, $8(%r13,%rcx,8) + LONG $0xfffdd2e9; BYTE $0xff // jmp LBB19_39, $-558(%rip) + +LBB19_35: + QUAD $0x00000200cd44c749; BYTE $0x00 // movq $2, (%r13,%rcx,8) + QUAD $0xffffffffd045c748 // movq $-1, $-48(%rbp) + WORD $0x8b4d; BYTE $0x38 // movq (%r8), %r15 + WORD $0x894c; BYTE $0xf7 // movq %r14, %rdi + WORD $0x894c; BYTE $0xfe // movq %r15, %rsi + LONG $0xd0558d48 // leaq $-48(%rbp), %rdx + LONG $0xb84d8b48 // movq $-72(%rbp), %rcx + WORD $0x894c; BYTE $0xc3 // movq %r8, %rbx + LONG $0xffefb8e8; BYTE $0xff // callq _advance_string, $-4168(%rip) + WORD $0x8949; BYTE $0xc6 // movq %rax, %r14 + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0x018a880f; WORD $0x0000 // js LBB19_55, $394(%rip) + WORD $0x894c; BYTE $0x33 // movq %r14, (%rbx) + WORD $0x854d; BYTE $0xff // testq %r15, %r15 + LONG $0x01968e0f; WORD $0x0000 // jle LBB19_56, $406(%rip) + LONG $0x00458b49 // movq (%r13), %rax + LONG $0x0fff3d48; WORD $0x0000 // cmpq $4095, %rax + LONG $0x01628f0f; WORD $0x0000 // jg LBB19_58, $354(%rip) + WORD $0x8949; BYTE $0xd8 // movq %rbx, %r8 + LONG $0x01488d48 // leaq $1(%rax), %rcx + LONG $0x004d8949 // movq %rcx, (%r13) + QUAD $0x00000408c544c749; BYTE $0x00 // movq $4, $8(%r13,%rax,8) + LONG $0xfffd67e9; BYTE $0xff // jmp LBB19_39, $-665(%rip) + +LBB19_40: + QUAD $0xffffffffd045c748 // movq $-1, $-48(%rbp) + WORD $0x8b4d; BYTE $0x38 // movq (%r8), %r15 + LONG $0xc87d8b48 // movq $-56(%rbp), %rdi + LONG $0xfffe3ee9; BYTE $0xff // jmp LBB19_18, $-450(%rip) + +LBB19_41: + WORD $0x8b4d; BYTE $0x30 // movq (%r8), %r14 + LONG $0xc8458b48 // movq $-56(%rbp), %rax + WORD $0x8b48; BYTE $0x38 // movq (%rax), %rdi + WORD $0x014c; BYTE $0xf7 // addq %r14, %rdi + LONG $0x08708b48 // movq $8(%rax), %rsi + WORD $0x294c; BYTE $0xf6 // subq %r14, %rsi + WORD $0x894c; BYTE $0xc3 // movq %r8, %rbx + LONG $0x0006f7e8; BYTE $0x00 // callq _do_skip_number, $1783(%rip) WORD $0x8548; BYTE $0xc0 // testq %rax, %rax - LONG $0x0143880f; WORD $0x0000 // js LBB23_70, $323(%rip) + LONG $0x017f880f; WORD $0x0000 // js LBB19_63, $383(%rip) WORD $0x0148; BYTE $0x03 // addq %rax, (%rbx) - WORD $0x854d; BYTE $0xed // testq %r13, %r13 - LONG $0xfd2b8f0f; WORD $0xffff // jg LBB23_6, $-725(%rip) - LONG $0x000144e9; BYTE $0x00 // jmp LBB23_72, $324(%rip) - -LBB23_44: - WORD $0x8b49; BYTE $0x0f // movq (%r15), %rcx - LONG $0x000005b8; BYTE $0x00 // movl $5, %eax - LONG $0xfff98148; WORD $0x000f; BYTE $0x00 // cmpq $4095, %rcx - LONG $0xfd028e0f; WORD $0xffff // jle LBB23_4, $-766(%rip) - LONG $0x0000d9e9; BYTE $0x00 // jmp LBB23_65, $217(%rip) + WORD $0x854d; BYTE $0xf6 // testq %r14, %r14 + WORD $0x8949; BYTE $0xd8 // movq %rbx, %r8 + LONG $0xfd1f8f0f; WORD $0xffff // jg LBB19_39, $-737(%rip) + LONG $0x000176e9; BYTE $0x00 // jmp LBB19_68, $374(%rip) + +LBB19_43: + LONG $0x00458b49 // movq (%r13), %rax + LONG $0x0fff3d48; WORD $0x0000 // cmpq $4095, %rax + LONG $0x00ec8f0f; WORD $0x0000 // jg LBB19_58, $236(%rip) + LONG $0x01488d48 // leaq $1(%rax), %rcx + LONG $0x004d8949 // movq %rcx, (%r13) + QUAD $0x00000508c544c749; BYTE $0x00 // movq $5, $8(%r13,%rax,8) + LONG $0xfffcf4e9; BYTE $0xff // jmp LBB19_39, $-780(%rip) -LBB23_45: - WORD $0x8b48; BYTE $0x03 // movq (%rbx), %rax - LONG $0x084e8b49 // movq $8(%r14), %rcx +LBB19_45: + WORD $0x8b49; BYTE $0x00 // movq (%r8), %rax + LONG $0xc04d8b48 // movq $-64(%rbp), %rcx + WORD $0x8b48; BYTE $0x09 // movq (%rcx), %rcx LONG $0xfc518d48 // leaq $-4(%rcx), %rdx WORD $0x3948; BYTE $0xd0 // cmpq %rdx, %rax - LONG $0x00ea870f; WORD $0x0000 // ja LBB23_67, $234(%rip) - WORD $0x8b49; BYTE $0x0e // movq (%r14), %rcx + LONG $0x0114870f; WORD $0x0000 // ja LBB19_61, $276(%rip) + LONG $0xc84d8b48 // movq $-56(%rbp), %rcx + WORD $0x8b48; BYTE $0x09 // movq (%rcx), %rcx WORD $0x148b; BYTE $0x01 // movl (%rcx,%rax), %edx LONG $0x6c61fa81; WORD $0x6573 // cmpl $1702063201, %edx - LONG $0x015b850f; WORD $0x0000 // jne LBB23_77, $347(%rip) + LONG $0x01d0850f; WORD $0x0000 // jne LBB19_78, $464(%rip) LONG $0x04488d48 // leaq $4(%rax), %rcx - WORD $0x8948; BYTE $0x0b // movq %rcx, (%rbx) + WORD $0x8949; BYTE $0x08 // movq %rcx, (%r8) WORD $0x8548; BYTE $0xc0 // testq %rax, %rax - LONG $0xfcd68f0f; WORD $0xffff // jg LBB23_6, $-810(%rip) - LONG $0x0000d2e9; BYTE $0x00 // jmp LBB23_68, $210(%rip) + LONG $0xfcb78f0f; WORD $0xffff // jg LBB19_39, $-841(%rip) + LONG $0x0000f8e9; BYTE $0x00 // jmp LBB19_62, $248(%rip) -LBB23_48: - WORD $0x8b48; BYTE $0x03 // movq (%rbx), %rax - LONG $0x084e8b49 // movq $8(%r14), %rcx +LBB19_48: + WORD $0x8b49; BYTE $0x00 // movq (%r8), %rax + LONG $0xc04d8b48 // movq $-64(%rbp), %rcx + WORD $0x8b48; BYTE $0x09 // movq (%rcx), %rcx LONG $0xfd518d48 // leaq $-3(%rcx), %rdx WORD $0x3948; BYTE $0xd0 // cmpq %rdx, %rax - LONG $0x00af870f; WORD $0x0000 // ja LBB23_67, $175(%rip) - WORD $0x8b49; BYTE $0x0e // movq (%r14), %rcx + LONG $0x00d2870f; WORD $0x0000 // ja LBB19_61, $210(%rip) + LONG $0xc84d8b48 // movq $-56(%rbp), %rcx + WORD $0x8b48; BYTE $0x09 // movq (%rcx), %rcx QUAD $0x6c6c756eff017c81 // cmpl $1819047278, $-1(%rcx,%rax) - LONG $0x002a840f; WORD $0x0000 // je LBB23_52, $42(%rip) - LONG $0x0000cde9; BYTE $0x00 // jmp LBB23_73, $205(%rip) + LONG $0xfc73840f; WORD $0xffff // je LBB19_3, $-909(%rip) + LONG $0x0000e5e9; BYTE $0x00 // jmp LBB19_69, $229(%rip) -LBB23_50: - WORD $0x8b48; BYTE $0x03 // movq (%rbx), %rax - LONG $0x084e8b49 // movq $8(%r14), %rcx +LBB19_50: + WORD $0x8b49; BYTE $0x00 // movq (%r8), %rax + LONG $0xc04d8b48 // movq $-64(%rbp), %rcx + WORD $0x8b48; BYTE $0x09 // movq (%rcx), %rcx LONG $0xfd518d48 // leaq $-3(%rcx), %rdx WORD $0x3948; BYTE $0xd0 // cmpq %rdx, %rax - LONG $0x0085870f; WORD $0x0000 // ja LBB23_67, $133(%rip) - WORD $0x8b49; BYTE $0x0e // movq (%r14), %rcx + LONG $0x00a1870f; WORD $0x0000 // ja LBB19_61, $161(%rip) + LONG $0xc84d8b48 // movq $-56(%rbp), %rcx + WORD $0x8b48; BYTE $0x09 // movq (%rcx), %rcx QUAD $0x65757274ff017c81 // cmpl $1702195828, $-1(%rcx,%rax) - LONG $0x0149850f; WORD $0x0000 // jne LBB23_82, $329(%rip) + LONG $0xfc42840f; WORD $0xffff // je LBB19_3, $-958(%rip) + LONG $0x000103e9; BYTE $0x00 // jmp LBB19_73, $259(%rip) -LBB23_52: - LONG $0x03488d48 // leaq $3(%rax), %rcx - WORD $0x8948; BYTE $0x0b // movq %rcx, (%rbx) - WORD $0x8548; BYTE $0xc0 // testq %rax, %rax - LONG $0xfc728f0f; WORD $0xffff // jg LBB23_6, $-910(%rip) - LONG $0x00006ee9; BYTE $0x00 // jmp LBB23_68, $110(%rip) +LBB19_52: + LONG $0x00458b49 // movq (%r13), %rax + LONG $0x0fff3d48; WORD $0x0000 // cmpq $4095, %rax + LONG $0x00228f0f; WORD $0x0000 // jg LBB19_58, $34(%rip) + LONG $0x01488d48 // leaq $1(%rax), %rcx + LONG $0x004d8949 // movq %rcx, (%r13) + QUAD $0x00000608c544c749; BYTE $0x00 // movq $6, $8(%r13,%rax,8) + LONG $0xfffc2ae9; BYTE $0xff // jmp LBB19_39, $-982(%rip) + +LBB19_2: + LONG $0xffc6c749; WORD $0xffff; BYTE $0xff // movq $-1, %r14 + LONG $0x000043e9; BYTE $0x00 // jmp LBB19_65, $67(%rip) -LBB23_53: - WORD $0xff48; BYTE $0xcb // decq %rbx - WORD $0x894c; BYTE $0xe8 // movq %r13, %rax - WORD $0x8949; BYTE $0xdd // movq %rbx, %r13 +LBB19_58: + LONG $0xf9c6c749; WORD $0xffff; BYTE $0xff // movq $-7, %r14 + LONG $0x000037e9; BYTE $0x00 // jmp LBB19_65, $55(%rip) + +LBB19_55: + LONG $0xfffe8349 // cmpq $-1, %r14 + LONG $0xd0458d48 // leaq $-48(%rbp), %rax + LONG $0x45440f48; BYTE $0xc0 // cmoveq $-64(%rbp), %rax + WORD $0x8b48; BYTE $0x00 // movq (%rax), %rax + WORD $0x8948; BYTE $0x03 // movq %rax, (%rbx) + LONG $0x00001fe9; BYTE $0x00 // jmp LBB19_65, $31(%rip) -LBB23_54: - WORD $0x894c; BYTE $0xf3 // movq %r14, %rbx - WORD $0x8949; BYTE $0x06 // movq %rax, (%r14) - WORD $0x854d; BYTE $0xed // testq %r13, %r13 - LONG $0xc8758b4c // movq $-56(%rbp), %r14 - LONG $0xfc51890f; WORD $0xffff // jns LBB23_6, $-943(%rip) - LONG $0x000007e9; BYTE $0x00 // jmp LBB23_57, $7(%rip) +LBB19_56: + WORD $0xff49; BYTE $0xcf // decq %r15 + WORD $0x894d; BYTE $0xfe // movq %r15, %r14 + LONG $0x000014e9; BYTE $0x00 // jmp LBB19_65, $20(%rip) -LBB23_2: - LONG $0xffc5c749; WORD $0xffff; BYTE $0xff // movq $-1, %r13 +LBB19_57: + WORD $0x8b48; BYTE $0x0b // movq (%rbx), %rcx + WORD $0x2948; BYTE $0xc1 // subq %rax, %rcx + LONG $0xfec18348 // addq $-2, %rcx + WORD $0x8948; BYTE $0x0b // movq %rcx, (%rbx) -LBB23_57: - WORD $0x894c; BYTE $0xe8 // movq %r13, %rax - LONG $0x18c48348 // addq $24, %rsp +LBB19_64: + LONG $0xfec6c749; WORD $0xffff; BYTE $0xff // movq $-2, %r14 + +LBB19_65: + WORD $0x894c; BYTE $0xf0 // movq %r14, %rax + LONG $0x28c48348 // addq $40, %rsp BYTE $0x5b // popq %rbx WORD $0x5c41 // popq %r12 WORD $0x5d41 // popq %r13 @@ -6869,257 +6389,240 @@ LBB23_57: BYTE $0x5d // popq %rbp BYTE $0xc3 // retq -LBB23_65: - LONG $0xf9c5c749; WORD $0xffff; BYTE $0xff // movq $-7, %r13 - LONG $0xffffe2e9; BYTE $0xff // jmp LBB23_57, $-30(%rip) - -LBB23_60: - WORD $0x8b48; BYTE $0x0b // movq (%rbx), %rcx - WORD $0x2948; BYTE $0xc1 // subq %rax, %rcx - LONG $0xfec18348 // addq $-2, %rcx - WORD $0x8948; BYTE $0x0b // movq %rcx, (%rbx) - -LBB23_61: - LONG $0xfec5c749; WORD $0xffff; BYTE $0xff // movq $-2, %r13 - LONG $0xffffc9e9; BYTE $0xff // jmp LBB23_57, $-55(%rip) - -LBB23_67: - WORD $0x8948; BYTE $0x0b // movq %rcx, (%rbx) - LONG $0xffc5c749; WORD $0xffff; BYTE $0xff // movq $-1, %r13 - LONG $0xffffbae9; BYTE $0xff // jmp LBB23_57, $-70(%rip) - -LBB23_68: - WORD $0xff48; BYTE $0xc8 // decq %rax +LBB19_61: + WORD $0x8949; BYTE $0x08 // movq %rcx, (%r8) + LONG $0xffc6c749; WORD $0xffff; BYTE $0xff // movq $-1, %r14 + LONG $0xffffdfe9; BYTE $0xff // jmp LBB19_65, $-33(%rip) -LBB23_56: - WORD $0x8949; BYTE $0xc5 // movq %rax, %r13 - LONG $0xffffafe9; BYTE $0xff // jmp LBB23_57, $-81(%rip) +LBB19_62: + WORD $0xff48; BYTE $0xc8 // decq %rax + WORD $0x8949; BYTE $0xc6 // movq %rax, %r14 + LONG $0xffffd4e9; BYTE $0xff // jmp LBB19_65, $-44(%rip) -LBB23_70: - WORD $0xf748; BYTE $0xd0 // notq %rax - WORD $0x0148; BYTE $0x03 // addq %rax, (%rbx) - LONG $0xfec5c749; WORD $0xffff; BYTE $0xff // movq $-2, %r13 - LONG $0xffff9de9; BYTE $0xff // jmp LBB23_57, $-99(%rip) +LBB19_63: + WORD $0xf748; BYTE $0xd0 // notq %rax + WORD $0x0148; BYTE $0x03 // addq %rax, (%rbx) + LONG $0xffffc2e9; BYTE $0xff // jmp LBB19_64, $-62(%rip) -LBB23_72: - WORD $0xff49; BYTE $0xcd // decq %r13 - LONG $0xffff95e9; BYTE $0xff // jmp LBB23_57, $-107(%rip) +LBB19_68: + WORD $0xff49; BYTE $0xce // decq %r14 + LONG $0xffffc1e9; BYTE $0xff // jmp LBB19_65, $-63(%rip) -LBB23_73: +LBB19_69: LONG $0xff508d48 // leaq $-1(%rax), %rdx - WORD $0x8948; BYTE $0x13 // movq %rdx, (%rbx) - LONG $0xfec5c749; WORD $0xffff; BYTE $0xff // movq $-2, %r13 + WORD $0x8949; BYTE $0x10 // movq %rdx, (%r8) + LONG $0xfec6c749; WORD $0xffff; BYTE $0xff // movq $-2, %r14 LONG $0xff017c80; BYTE $0x6e // cmpb $110, $-1(%rcx,%rax) - LONG $0xff7c850f; WORD $0xffff // jne LBB23_57, $-132(%rip) - WORD $0x8948; BYTE $0x03 // movq %rax, (%rbx) + LONG $0xffa8850f; WORD $0xffff // jne LBB19_65, $-88(%rip) + WORD $0x8949; BYTE $0x00 // movq %rax, (%r8) LONG $0x75013c80 // cmpb $117, (%rcx,%rax) - LONG $0xff6f850f; WORD $0xffff // jne LBB23_57, $-145(%rip) + LONG $0xff9b850f; WORD $0xffff // jne LBB19_65, $-101(%rip) LONG $0x01508d48 // leaq $1(%rax), %rdx - WORD $0x8948; BYTE $0x13 // movq %rdx, (%rbx) + WORD $0x8949; BYTE $0x10 // movq %rdx, (%r8) LONG $0x01017c80; BYTE $0x6c // cmpb $108, $1(%rcx,%rax) - LONG $0xff5d850f; WORD $0xffff // jne LBB23_57, $-163(%rip) + LONG $0xff89850f; WORD $0xffff // jne LBB19_65, $-119(%rip) LONG $0x02508d48 // leaq $2(%rax), %rdx - WORD $0x8948; BYTE $0x13 // movq %rdx, (%rbx) + WORD $0x8949; BYTE $0x10 // movq %rdx, (%r8) LONG $0x02017c80; BYTE $0x6c // cmpb $108, $2(%rcx,%rax) - LONG $0xff4b850f; WORD $0xffff // jne LBB23_57, $-181(%rip) - LONG $0x00009ce9; BYTE $0x00 // jmp LBB23_86, $156(%rip) - -LBB23_77: - LONG $0xfec5c749; WORD $0xffff; BYTE $0xff // movq $-2, %r13 - WORD $0xfa80; BYTE $0x61 // cmpb $97, %dl - LONG $0xff36850f; WORD $0xffff // jne LBB23_57, $-202(%rip) - LONG $0x01508d48 // leaq $1(%rax), %rdx - WORD $0x8948; BYTE $0x13 // movq %rdx, (%rbx) - LONG $0x01017c80; BYTE $0x6c // cmpb $108, $1(%rcx,%rax) - LONG $0xff24850f; WORD $0xffff // jne LBB23_57, $-220(%rip) - LONG $0x02508d48 // leaq $2(%rax), %rdx - WORD $0x8948; BYTE $0x13 // movq %rdx, (%rbx) - LONG $0x02017c80; BYTE $0x73 // cmpb $115, $2(%rcx,%rax) - LONG $0xff12850f; WORD $0xffff // jne LBB23_57, $-238(%rip) - LONG $0x03508d48 // leaq $3(%rax), %rdx - WORD $0x8948; BYTE $0x13 // movq %rdx, (%rbx) - LONG $0x03017c80; BYTE $0x65 // cmpb $101, $3(%rcx,%rax) - LONG $0xff00850f; WORD $0xffff // jne LBB23_57, $-256(%rip) - LONG $0x04c08348 // addq $4, %rax - WORD $0x8948; BYTE $0x03 // movq %rax, (%rbx) - LONG $0xfffef4e9; BYTE $0xff // jmp LBB23_57, $-268(%rip) + LONG $0xff77850f; WORD $0xffff // jne LBB19_65, $-137(%rip) + LONG $0x00004ae9; BYTE $0x00 // jmp LBB19_77, $74(%rip) -LBB23_82: +LBB19_73: LONG $0xff508d48 // leaq $-1(%rax), %rdx - WORD $0x8948; BYTE $0x13 // movq %rdx, (%rbx) - LONG $0xfec5c749; WORD $0xffff; BYTE $0xff // movq $-2, %r13 + WORD $0x8949; BYTE $0x10 // movq %rdx, (%r8) + LONG $0xfec6c749; WORD $0xffff; BYTE $0xff // movq $-2, %r14 LONG $0xff017c80; BYTE $0x74 // cmpb $116, $-1(%rcx,%rax) - LONG $0xfedb850f; WORD $0xffff // jne LBB23_57, $-293(%rip) - WORD $0x8948; BYTE $0x03 // movq %rax, (%rbx) + LONG $0xff59850f; WORD $0xffff // jne LBB19_65, $-167(%rip) + WORD $0x8949; BYTE $0x00 // movq %rax, (%r8) LONG $0x72013c80 // cmpb $114, (%rcx,%rax) - LONG $0xfece850f; WORD $0xffff // jne LBB23_57, $-306(%rip) + LONG $0xff4c850f; WORD $0xffff // jne LBB19_65, $-180(%rip) LONG $0x01508d48 // leaq $1(%rax), %rdx - WORD $0x8948; BYTE $0x13 // movq %rdx, (%rbx) + WORD $0x8949; BYTE $0x10 // movq %rdx, (%r8) LONG $0x01017c80; BYTE $0x75 // cmpb $117, $1(%rcx,%rax) - LONG $0xfebc850f; WORD $0xffff // jne LBB23_57, $-324(%rip) + LONG $0xff3a850f; WORD $0xffff // jne LBB19_65, $-198(%rip) LONG $0x02508d48 // leaq $2(%rax), %rdx - WORD $0x8948; BYTE $0x13 // movq %rdx, (%rbx) + WORD $0x8949; BYTE $0x10 // movq %rdx, (%r8) LONG $0x02017c80; BYTE $0x65 // cmpb $101, $2(%rcx,%rax) - LONG $0xfeaa850f; WORD $0xffff // jne LBB23_57, $-342(%rip) + LONG $0xff28850f; WORD $0xffff // jne LBB19_65, $-216(%rip) -LBB23_86: +LBB19_77: LONG $0x03c08348 // addq $3, %rax - WORD $0x8948; BYTE $0x03 // movq %rax, (%rbx) - LONG $0xfffe9ee9; BYTE $0xff // jmp LBB23_57, $-354(%rip) + WORD $0x8949; BYTE $0x00 // movq %rax, (%r8) + LONG $0xffff1ce9; BYTE $0xff // jmp LBB19_65, $-228(%rip) - // .p2align 2, 0x90 - // .set L23_0_set_12, LBB23_12-LJTI23_0 - // .set L23_0_set_15, LBB23_15-LJTI23_0 - // .set L23_0_set_18, LBB23_18-LJTI23_0 - // .set L23_0_set_21, LBB23_21-LJTI23_0 - // .set L23_0_set_23, LBB23_23-LJTI23_0 - // .set L23_0_set_28, LBB23_28-LJTI23_0 -LJTI23_0: - LONG $0xfffffb45 // .long L23_0_set_12 - LONG $0xfffffb7a // .long L23_0_set_15 - LONG $0xfffffbac // .long L23_0_set_18 - LONG $0xfffffbe8 // .long L23_0_set_21 - LONG $0xfffffc00 // .long L23_0_set_23 - LONG $0xfffffc85 // .long L23_0_set_28 - - // .set L23_1_set_57, LBB23_57-LJTI23_1 - // .set L23_1_set_56, LBB23_56-LJTI23_1 - // .set L23_1_set_40, LBB23_40-LJTI23_1 - // .set L23_1_set_42, LBB23_42-LJTI23_1 - // .set L23_1_set_26, LBB23_26-LJTI23_1 - // .set L23_1_set_44, LBB23_44-LJTI23_1 - // .set L23_1_set_45, LBB23_45-LJTI23_1 - // .set L23_1_set_48, LBB23_48-LJTI23_1 - // .set L23_1_set_50, LBB23_50-LJTI23_1 - // .set L23_1_set_3, LBB23_3-LJTI23_1 -LJTI23_1: - LONG $0xfffffe86 // .long L23_1_set_57 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffd48 // .long L23_1_set_40 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffd76 // .long L23_1_set_42 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffc2a // .long L23_1_set_26 - LONG $0xfffffc2a // .long L23_1_set_26 - LONG $0xfffffc2a // .long L23_1_set_26 - LONG $0xfffffc2a // .long L23_1_set_26 - LONG $0xfffffc2a // .long L23_1_set_26 - LONG $0xfffffc2a // .long L23_1_set_26 - LONG $0xfffffc2a // .long L23_1_set_26 - LONG $0xfffffc2a // .long L23_1_set_26 - LONG $0xfffffc2a // .long L23_1_set_26 - LONG $0xfffffc2a // .long L23_1_set_26 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffda5 // .long L23_1_set_44 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffdbf // .long L23_1_set_45 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffdfa // .long L23_1_set_48 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffe24 // .long L23_1_set_50 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffecf // .long L23_1_set_56 - LONG $0xfffffaa4 // .long L23_1_set_3 +LBB19_78: + LONG $0xfec6c749; WORD $0xffff; BYTE $0xff // movq $-2, %r14 + WORD $0xfa80; BYTE $0x61 // cmpb $97, %dl + LONG $0xff0c850f; WORD $0xffff // jne LBB19_65, $-244(%rip) + LONG $0x01508d48 // leaq $1(%rax), %rdx + WORD $0x8949; BYTE $0x10 // movq %rdx, (%r8) + LONG $0x01017c80; BYTE $0x6c // cmpb $108, $1(%rcx,%rax) + LONG $0xfefa850f; WORD $0xffff // jne LBB19_65, $-262(%rip) + LONG $0x02508d48 // leaq $2(%rax), %rdx + WORD $0x8949; BYTE $0x10 // movq %rdx, (%r8) + LONG $0x02017c80; BYTE $0x73 // cmpb $115, $2(%rcx,%rax) + LONG $0xfee8850f; WORD $0xffff // jne LBB19_65, $-280(%rip) + LONG $0x03508d48 // leaq $3(%rax), %rdx + WORD $0x8949; BYTE $0x10 // movq %rdx, (%r8) + LONG $0x03017c80; BYTE $0x65 // cmpb $101, $3(%rcx,%rax) + LONG $0xfed6850f; WORD $0xffff // jne LBB19_65, $-298(%rip) + LONG $0x04c08348 // addq $4, %rax + WORD $0x8949; BYTE $0x00 // movq %rax, (%r8) + LONG $0xfffecae9; BYTE $0xff // jmp LBB19_65, $-310(%rip) + BYTE $0x90 // .p2align 2, 0x90 + + // .set L19_0_set_9, LBB19_9-LJTI19_0 + // .set L19_0_set_13, LBB19_13-LJTI19_0 + // .set L19_0_set_16, LBB19_16-LJTI19_0 + // .set L19_0_set_20, LBB19_20-LJTI19_0 + // .set L19_0_set_22, LBB19_22-LJTI19_0 + // .set L19_0_set_24, LBB19_24-LJTI19_0 +LJTI19_0: + LONG $0xfffffb10 // .long L19_0_set_9 + LONG $0xfffffb49 // .long L19_0_set_13 + LONG $0xfffffb70 // .long L19_0_set_16 + LONG $0xfffffbc2 // .long L19_0_set_20 + LONG $0xfffffbd8 // .long L19_0_set_22 + LONG $0xfffffbf5 // .long L19_0_set_24 + + // .set L19_1_set_65, LBB19_65-LJTI19_1 + // .set L19_1_set_64, LBB19_64-LJTI19_1 + // .set L19_1_set_40, LBB19_40-LJTI19_1 + // .set L19_1_set_41, LBB19_41-LJTI19_1 + // .set L19_1_set_29, LBB19_29-LJTI19_1 + // .set L19_1_set_43, LBB19_43-LJTI19_1 + // .set L19_1_set_45, LBB19_45-LJTI19_1 + // .set L19_1_set_48, LBB19_48-LJTI19_1 + // .set L19_1_set_50, LBB19_50-LJTI19_1 + // .set L19_1_set_52, LBB19_52-LJTI19_1 +LJTI19_1: + LONG $0xfffffeb1 // .long L19_1_set_65 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffd25 // .long L19_1_set_40 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffd39 // .long L19_1_set_41 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffc2f // .long L19_1_set_29 + LONG $0xfffffc2f // .long L19_1_set_29 + LONG $0xfffffc2f // .long L19_1_set_29 + LONG $0xfffffc2f // .long L19_1_set_29 + LONG $0xfffffc2f // .long L19_1_set_29 + LONG $0xfffffc2f // .long L19_1_set_29 + LONG $0xfffffc2f // .long L19_1_set_29 + LONG $0xfffffc2f // .long L19_1_set_29 + LONG $0xfffffc2f // .long L19_1_set_29 + LONG $0xfffffc2f // .long L19_1_set_29 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffd72 // .long L19_1_set_43 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffd98 // .long L19_1_set_45 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffdda // .long L19_1_set_48 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffe0b // .long L19_1_set_50 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffeaa // .long L19_1_set_64 + LONG $0xfffffe3c // .long L19_1_set_52 QUAD $0x0000000000000000; LONG $0x00000000 // .p2align 4, 0x00 -LCPI24_0: +LCPI20_0: QUAD $0x0000000000000001 // .quad 1 QUAD $0x0000000000000006 // .quad 6 @@ -7130,43 +6633,53 @@ _skip_object: WORD $0x8948; BYTE $0xd0 // movq %rdx, %rax WORD $0x8948; BYTE $0xf2 // movq %rsi, %rdx WORD $0x8948; BYTE $0xfe // movq %rdi, %rsi - QUAD $0xffffffdb0528f8c5 // vmovaps $-37(%rip), %xmm0 /* LCPI24_0(%rip) */ + QUAD $0xffffffdb0528f8c5 // vmovaps $-37(%rip), %xmm0 /* LCPI20_0(%rip) */ LONG $0x0011f8c5 // vmovups %xmm0, (%rax) WORD $0x8948; BYTE $0xc7 // movq %rax, %rdi BYTE $0x5d // popq %rbp - LONG $0xfff83ee9; BYTE $0xff // jmp _fsm_exec, $-1986(%rip) + LONG $0xfff80ee9; BYTE $0xff // jmp _fsm_exec, $-2034(%rip) QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 _skip_string: BYTE $0x55 // pushq %rbp WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5741 // pushq %r15 WORD $0x5641 // pushq %r14 + WORD $0x5441 // pushq %r12 BYTE $0x53 // pushq %rbx LONG $0x10ec8348 // subq $16, %rsp WORD $0x8948; BYTE $0xd1 // movq %rdx, %rcx WORD $0x8949; BYTE $0xf6 // movq %rsi, %r14 + WORD $0x8949; BYTE $0xff // movq %rdi, %r15 + QUAD $0xffffffffd845c748 // movq $-1, $-40(%rbp) WORD $0x8b48; BYTE $0x1e // movq (%rsi), %rbx - LONG $0xe8558d48 // leaq $-24(%rbp), %rdx + LONG $0xd8658d4c // leaq $-40(%rbp), %r12 WORD $0x8948; BYTE $0xde // movq %rbx, %rsi - LONG $0xffeaf0e8; BYTE $0xff // callq _advance_string, $-5392(%rip) + WORD $0x894c; BYTE $0xe2 // movq %r12, %rdx + LONG $0xffea2ee8; BYTE $0xff // callq _advance_string, $-5586(%rip) WORD $0x8548; BYTE $0xc0 // testq %rax, %rax - LONG $0x0009890f; WORD $0x0000 // jns LBB25_1, $9(%rip) - LONG $0xe84d8b48 // movq $-24(%rbp), %rcx - LONG $0x000009e9; BYTE $0x00 // jmp LBB25_3, $9(%rip) + LONG $0x000e880f; WORD $0x0000 // js LBB21_1, $14(%rip) + WORD $0xff48; BYTE $0xcb // decq %rbx + WORD $0x8948; BYTE $0xc1 // movq %rax, %rcx + WORD $0x8948; BYTE $0xd8 // movq %rbx, %rax + LONG $0x000010e9; BYTE $0x00 // jmp LBB21_3, $16(%rip) -LBB25_1: - WORD $0xff48; BYTE $0xcb // decq %rbx - WORD $0x8948; BYTE $0xc1 // movq %rax, %rcx - WORD $0x8948; BYTE $0xd8 // movq %rbx, %rax +LBB21_1: + LONG $0x08c78349 // addq $8, %r15 + LONG $0xfff88348 // cmpq $-1, %rax + LONG $0xe7440f4d // cmoveq %r15, %r12 + LONG $0x240c8b49 // movq (%r12), %rcx -LBB25_3: - WORD $0x8949; BYTE $0x0e // movq %rcx, (%r14) - LONG $0x10c48348 // addq $16, %rsp - BYTE $0x5b // popq %rbx - WORD $0x5e41 // popq %r14 - BYTE $0x5d // popq %rbp - BYTE $0xc3 // retq - QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90 +LBB21_3: + WORD $0x8949; BYTE $0x0e // movq %rcx, (%r14) + LONG $0x10c48348 // addq $16, %rsp + BYTE $0x5b // popq %rbx + WORD $0x5c41 // popq %r12 + WORD $0x5e41 // popq %r14 + WORD $0x5f41 // popq %r15 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 _skip_negative: BYTE $0x55 // pushq %rbp @@ -7180,74 +6693,74 @@ _skip_negative: LONG $0x08778b48 // movq $8(%rdi), %rsi WORD $0x2948; BYTE $0xde // subq %rbx, %rsi WORD $0x8948; BYTE $0xc7 // movq %rax, %rdi - LONG $0x00018ee8; BYTE $0x00 // callq _do_skip_number, $398(%rip) + LONG $0x00017ee8; BYTE $0x00 // callq _do_skip_number, $382(%rip) WORD $0x8548; BYTE $0xc0 // testq %rax, %rax - LONG $0x000b880f; WORD $0x0000 // js LBB26_1, $11(%rip) + LONG $0x000b880f; WORD $0x0000 // js LBB22_1, $11(%rip) WORD $0x0149; BYTE $0x06 // addq %rax, (%r14) WORD $0xff48; BYTE $0xcb // decq %rbx - LONG $0x00000de9; BYTE $0x00 // jmp LBB26_3, $13(%rip) + LONG $0x00000de9; BYTE $0x00 // jmp LBB22_3, $13(%rip) -LBB26_1: +LBB22_1: WORD $0xf748; BYTE $0xd0 // notq %rax WORD $0x0149; BYTE $0x06 // addq %rax, (%r14) LONG $0xfec3c748; WORD $0xffff; BYTE $0xff // movq $-2, %rbx -LBB26_3: - WORD $0x8948; BYTE $0xd8 // movq %rbx, %rax - BYTE $0x5b // popq %rbx - WORD $0x5e41 // popq %r14 - BYTE $0x5d // popq %rbp - BYTE $0xc3 // retq - QUAD $0x0000000000000000; QUAD $0x0000000000000000; LONG $0x00000000; BYTE $0x00 // .p2align 5, 0x00 +LBB22_3: + WORD $0x8948; BYTE $0xd8 // movq %rbx, %rax + BYTE $0x5b // popq %rbx + WORD $0x5e41 // popq %r14 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + LONG $0x00000000; BYTE $0x00 // .p2align 5, 0x00 -LCPI27_0: +LCPI23_0: + QUAD $0x2f2f2f2f2f2f2f2f; QUAD $0x2f2f2f2f2f2f2f2f // .space 16, '////////////////' + QUAD $0x2f2f2f2f2f2f2f2f; QUAD $0x2f2f2f2f2f2f2f2f // .space 16, '////////////////' + +LCPI23_1: + QUAD $0x3a3a3a3a3a3a3a3a; QUAD $0x3a3a3a3a3a3a3a3a // .space 16, '::::::::::::::::' + QUAD $0x3a3a3a3a3a3a3a3a; QUAD $0x3a3a3a3a3a3a3a3a // .space 16, '::::::::::::::::' + +LCPI23_2: QUAD $0x2b2b2b2b2b2b2b2b; QUAD $0x2b2b2b2b2b2b2b2b // .space 16, '++++++++++++++++' QUAD $0x2b2b2b2b2b2b2b2b; QUAD $0x2b2b2b2b2b2b2b2b // .space 16, '++++++++++++++++' -LCPI27_1: +LCPI23_3: QUAD $0x2d2d2d2d2d2d2d2d; QUAD $0x2d2d2d2d2d2d2d2d // .space 16, '----------------' QUAD $0x2d2d2d2d2d2d2d2d; QUAD $0x2d2d2d2d2d2d2d2d // .space 16, '----------------' -LCPI27_2: +LCPI23_4: QUAD $0xdfdfdfdfdfdfdfdf; QUAD $0xdfdfdfdfdfdfdfdf // .space 16, '\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf' QUAD $0xdfdfdfdfdfdfdfdf; QUAD $0xdfdfdfdfdfdfdfdf // .space 16, '\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf' -LCPI27_3: +LCPI23_5: QUAD $0x2e2e2e2e2e2e2e2e; QUAD $0x2e2e2e2e2e2e2e2e // .space 16, '................' QUAD $0x2e2e2e2e2e2e2e2e; QUAD $0x2e2e2e2e2e2e2e2e // .space 16, '................' -LCPI27_4: +LCPI23_6: QUAD $0x4545454545454545; QUAD $0x4545454545454545 // .space 16, 'EEEEEEEEEEEEEEEE' QUAD $0x4545454545454545; QUAD $0x4545454545454545 // .space 16, 'EEEEEEEEEEEEEEEE' -LCPI27_5: - QUAD $0xd0d0d0d0d0d0d0d0; QUAD $0xd0d0d0d0d0d0d0d0 // .space 16, '\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0' - QUAD $0xd0d0d0d0d0d0d0d0; QUAD $0xd0d0d0d0d0d0d0d0 // .space 16, '\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0' + // .p2align 4, 0x00 +LCPI23_7: + QUAD $0x2f2f2f2f2f2f2f2f; QUAD $0x2f2f2f2f2f2f2f2f // .space 16, '////////////////' -LCPI27_6: - QUAD $0x0909090909090909; QUAD $0x0909090909090909 // .space 16, '\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t' - QUAD $0x0909090909090909; QUAD $0x0909090909090909 // .space 16, '\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t' +LCPI23_8: + QUAD $0x3a3a3a3a3a3a3a3a; QUAD $0x3a3a3a3a3a3a3a3a // .space 16, '::::::::::::::::' - // .p2align 4, 0x00 -LCPI27_7: +LCPI23_9: QUAD $0x2b2b2b2b2b2b2b2b; QUAD $0x2b2b2b2b2b2b2b2b // .space 16, '++++++++++++++++' -LCPI27_8: +LCPI23_10: QUAD $0x2d2d2d2d2d2d2d2d; QUAD $0x2d2d2d2d2d2d2d2d // .space 16, '----------------' -LCPI27_9: - QUAD $0xd0d0d0d0d0d0d0d0; QUAD $0xd0d0d0d0d0d0d0d0 // .space 16, '\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0' - -LCPI27_10: - QUAD $0x0909090909090909; QUAD $0x0909090909090909 // .space 16, '\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t' - -LCPI27_11: +LCPI23_11: QUAD $0xdfdfdfdfdfdfdfdf; QUAD $0xdfdfdfdfdfdfdfdf // .space 16, '\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf' -LCPI27_12: +LCPI23_12: QUAD $0x2e2e2e2e2e2e2e2e; QUAD $0x2e2e2e2e2e2e2e2e // .space 16, '................' -LCPI27_13: +LCPI23_13: QUAD $0x4545454545454545; QUAD $0x4545454545454545 // .space 16, 'EEEEEEEEEEEEEEEE' // .p2align 4, 0x90 @@ -7256,422 +6769,439 @@ _do_skip_number: WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp WORD $0x5741 // pushq %r15 WORD $0x5641 // pushq %r14 - WORD $0x5441 // pushq %r12 BYTE $0x53 // pushq %rbx WORD $0x8548; BYTE $0xf6 // testq %rsi, %rsi - LONG $0x03a4840f; WORD $0x0000 // je LBB27_1, $932(%rip) + LONG $0x03a8840f; WORD $0x0000 // je LBB23_52, $936(%rip) WORD $0x3f80; BYTE $0x30 // cmpb $48, (%rdi) - LONG $0x0033850f; WORD $0x0000 // jne LBB27_6, $51(%rip) - LONG $0x000001b8; BYTE $0x00 // movl $1, %eax + LONG $0x0033850f; WORD $0x0000 // jne LBB23_5, $51(%rip) + LONG $0x000001ba; BYTE $0x00 // movl $1, %edx LONG $0x01fe8348 // cmpq $1, %rsi - LONG $0x04b8840f; WORD $0x0000 // je LBB27_81, $1208(%rip) - LONG $0x014fb60f // movzbl $1(%rdi), %ecx - WORD $0xc183; BYTE $0xd2 // addl $-46, %ecx - WORD $0xf983; BYTE $0x37 // cmpl $55, %ecx - LONG $0x04a8870f; WORD $0x0000 // ja LBB27_81, $1192(%rip) - QUAD $0x000000800001ba48; WORD $0x0080 // movabsq $36028797027352577, %rdx - LONG $0xcaa30f48 // btq %rcx, %rdx - LONG $0x0494830f; WORD $0x0000 // jae LBB27_81, $1172(%rip) + LONG $0x047c840f; WORD $0x0000 // je LBB23_71, $1148(%rip) + WORD $0x478a; BYTE $0x01 // movb $1(%rdi), %al + WORD $0xd204 // addb $-46, %al + WORD $0x373c // cmpb $55, %al + LONG $0x046f870f; WORD $0x0000 // ja LBB23_71, $1135(%rip) + WORD $0xb60f; BYTE $0xc0 // movzbl %al, %eax + QUAD $0x000000800001b948; WORD $0x0080 // movabsq $36028797027352577, %rcx + LONG $0xc1a30f48 // btq %rax, %rcx + LONG $0x0458830f; WORD $0x0000 // jae LBB23_71, $1112(%rip) -LBB27_6: +LBB23_5: LONG $0xffc1c749; WORD $0xffff; BYTE $0xff // movq $-1, %r9 LONG $0x20fe8348 // cmpq $32, %rsi - LONG $0x048f820f; WORD $0x0000 // jb LBB27_7, $1167(%rip) - WORD $0xc031 // xorl %eax, %eax - QUAD $0xfffffe45056ffdc5 // vmovdqa $-443(%rip), %ymm0 /* LCPI27_0(%rip) */ - QUAD $0xfffffe5d0d6ffdc5 // vmovdqa $-419(%rip), %ymm1 /* LCPI27_1(%rip) */ - QUAD $0xfffffe75156ffdc5 // vmovdqa $-395(%rip), %ymm2 /* LCPI27_2(%rip) */ - QUAD $0xfffffe8d1d6ffdc5 // vmovdqa $-371(%rip), %ymm3 /* LCPI27_3(%rip) */ - QUAD $0xfffffea5256ffdc5 // vmovdqa $-347(%rip), %ymm4 /* LCPI27_4(%rip) */ - QUAD $0xfffffebd2d6ffdc5 // vmovdqa $-323(%rip), %ymm5 /* LCPI27_5(%rip) */ - QUAD $0xfffffed5356ffdc5 // vmovdqa $-299(%rip), %ymm6 /* LCPI27_6(%rip) */ + LONG $0x0474820f; WORD $0x0000 // jb LBB23_74, $1140(%rip) + QUAD $0xfffffe49056ffdc5 // vmovdqa $-439(%rip), %ymm0 /* LCPI23_0(%rip) */ + QUAD $0xfffffe610d6ffdc5 // vmovdqa $-415(%rip), %ymm1 /* LCPI23_1(%rip) */ + QUAD $0xfffffe79156ffdc5 // vmovdqa $-391(%rip), %ymm2 /* LCPI23_2(%rip) */ + QUAD $0xfffffe911d6ffdc5 // vmovdqa $-367(%rip), %ymm3 /* LCPI23_3(%rip) */ + QUAD $0xfffffea9256ffdc5 // vmovdqa $-343(%rip), %ymm4 /* LCPI23_4(%rip) */ + QUAD $0xfffffec12d6ffdc5 // vmovdqa $-319(%rip), %ymm5 /* LCPI23_5(%rip) */ + QUAD $0xfffffed9356ffdc5 // vmovdqa $-295(%rip), %ymm6 /* LCPI23_6(%rip) */ + LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax LONG $0xffc0c749; WORD $0xffff; BYTE $0xff // movq $-1, %r8 - LONG $0xffc2c749; WORD $0xffff; BYTE $0xff // movq $-1, %r10 - LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + WORD $0x8949; BYTE $0xfa // movq %rdi, %r10 + QUAD $0x9090909090909090 // .p2align 4, 0x90 -LBB27_9: - LONG $0x3c6ffec5; BYTE $0x07 // vmovdqu (%rdi,%rax), %ymm7 - LONG $0xc07445c5 // vpcmpeqb %ymm0, %ymm7, %ymm8 - LONG $0xc97445c5 // vpcmpeqb %ymm1, %ymm7, %ymm9 - LONG $0xeb3541c4; BYTE $0xc0 // vpor %ymm8, %ymm9, %ymm8 - LONG $0xcadb45c5 // vpand %ymm2, %ymm7, %ymm9 - LONG $0xcc7435c5 // vpcmpeqb %ymm4, %ymm9, %ymm9 +LBB23_7: + LONG $0x6f7ec1c4; BYTE $0x3a // vmovdqu (%r10), %ymm7 + LONG $0xc06445c5 // vpcmpgtb %ymm0, %ymm7, %ymm8 + LONG $0xcf6475c5 // vpcmpgtb %ymm7, %ymm1, %ymm9 + LONG $0xdb3541c4; BYTE $0xc0 // vpand %ymm8, %ymm9, %ymm8 + LONG $0xca7445c5 // vpcmpeqb %ymm2, %ymm7, %ymm9 LONG $0xd37445c5 // vpcmpeqb %ymm3, %ymm7, %ymm10 - LONG $0xd77dc1c4; BYTE $0xd2 // vpmovmskb %ymm10, %edx - LONG $0xd77d41c4; BYTE $0xf9 // vpmovmskb %ymm9, %r15d - LONG $0xd77d41c4; BYTE $0xd8 // vpmovmskb %ymm8, %r11d - LONG $0xfdfcc5c5 // vpaddb %ymm5, %ymm7, %ymm7 - LONG $0xdeda45c5 // vpminub %ymm6, %ymm7, %ymm11 - LONG $0xff74a5c5 // vpcmpeqb %ymm7, %ymm11, %ymm7 LONG $0xeb2d41c4; BYTE $0xc9 // vpor %ymm9, %ymm10, %ymm9 - LONG $0xffebb5c5 // vpor %ymm7, %ymm9, %ymm7 + LONG $0xd4db45c5 // vpand %ymm4, %ymm7, %ymm10 + LONG $0xd6742dc5 // vpcmpeqb %ymm6, %ymm10, %ymm10 + LONG $0xfd74c5c5 // vpcmpeqb %ymm5, %ymm7, %ymm7 + LONG $0xd7d7fdc5 // vpmovmskb %ymm7, %edx + LONG $0xd77d41c4; BYTE $0xf2 // vpmovmskb %ymm10, %r14d + LONG $0xd77d41c4; BYTE $0xd9 // vpmovmskb %ymm9, %r11d + LONG $0xffebbdc5 // vpor %ymm7, %ymm8, %ymm7 + LONG $0xeb2d41c4; BYTE $0xc1 // vpor %ymm9, %ymm10, %ymm8 LONG $0xffebbdc5 // vpor %ymm7, %ymm8, %ymm7 LONG $0xcfd7fdc5 // vpmovmskb %ymm7, %ecx WORD $0xf748; BYTE $0xd1 // notq %rcx - LONG $0xf1bc0f4c // bsfq %rcx, %r14 - LONG $0x20fe8341 // cmpl $32, %r14d - LONG $0x0017840f; WORD $0x0000 // je LBB27_11, $23(%rip) + LONG $0xc9bc0f48 // bsfq %rcx, %rcx + WORD $0xf983; BYTE $0x20 // cmpl $32, %ecx + LONG $0x0014840f; WORD $0x0000 // je LBB23_9, $20(%rip) LONG $0xffffffbb; BYTE $0xff // movl $-1, %ebx - WORD $0x8944; BYTE $0xf1 // movl %r14d, %ecx WORD $0xe3d3 // shll %cl, %ebx WORD $0xd3f7 // notl %ebx WORD $0xda21 // andl %ebx, %edx - WORD $0x2141; BYTE $0xdf // andl %ebx, %r15d + WORD $0x2141; BYTE $0xde // andl %ebx, %r14d WORD $0x2144; BYTE $0xdb // andl %r11d, %ebx WORD $0x8941; BYTE $0xdb // movl %ebx, %r11d -LBB27_11: - WORD $0x4a8d; BYTE $0xff // leal $-1(%rdx), %ecx - WORD $0xd121 // andl %edx, %ecx - LONG $0x0384850f; WORD $0x0000 // jne LBB27_12, $900(%rip) - LONG $0xff4f8d41 // leal $-1(%r15), %ecx - WORD $0x2144; BYTE $0xf9 // andl %r15d, %ecx - LONG $0x0377850f; WORD $0x0000 // jne LBB27_12, $887(%rip) - LONG $0xff4b8d41 // leal $-1(%r11), %ecx - WORD $0x2144; BYTE $0xd9 // andl %r11d, %ecx - LONG $0x036a850f; WORD $0x0000 // jne LBB27_12, $874(%rip) +LBB23_9: + WORD $0x5a8d; BYTE $0xff // leal $-1(%rdx), %ebx + WORD $0xd321 // andl %edx, %ebx + LONG $0x0371850f; WORD $0x0000 // jne LBB23_69, $881(%rip) + LONG $0xff5e8d41 // leal $-1(%r14), %ebx + WORD $0x2144; BYTE $0xf3 // andl %r14d, %ebx + LONG $0x0364850f; WORD $0x0000 // jne LBB23_69, $868(%rip) + LONG $0xff5b8d41 // leal $-1(%r11), %ebx + WORD $0x2144; BYTE $0xdb // andl %r11d, %ebx + LONG $0x0357850f; WORD $0x0000 // jne LBB23_69, $855(%rip) WORD $0xd285 // testl %edx, %edx - LONG $0x0013840f; WORD $0x0000 // je LBB27_19, $19(%rip) - WORD $0xbc0f; BYTE $0xca // bsfl %edx, %ecx - LONG $0xfffa8349 // cmpq $-1, %r10 - LONG $0x035d850f; WORD $0x0000 // jne LBB27_82, $861(%rip) - WORD $0x0148; BYTE $0xc1 // addq %rax, %rcx - WORD $0x8949; BYTE $0xca // movq %rcx, %r10 - -LBB27_19: - WORD $0x8545; BYTE $0xff // testl %r15d, %r15d - LONG $0x0014840f; WORD $0x0000 // je LBB27_22, $20(%rip) - LONG $0xcfbc0f41 // bsfl %r15d, %ecx + LONG $0x0019840f; WORD $0x0000 // je LBB23_15, $25(%rip) + WORD $0x894c; BYTE $0xd3 // movq %r10, %rbx + WORD $0x2948; BYTE $0xfb // subq %rdi, %rbx + WORD $0xbc0f; BYTE $0xd2 // bsfl %edx, %edx + WORD $0x0148; BYTE $0xda // addq %rbx, %rdx LONG $0xfff88349 // cmpq $-1, %r8 - LONG $0x0340850f; WORD $0x0000 // jne LBB27_82, $832(%rip) - WORD $0x0148; BYTE $0xc1 // addq %rax, %rcx - WORD $0x8949; BYTE $0xc8 // movq %rcx, %r8 + LONG $0x0342850f; WORD $0x0000 // jne LBB23_70, $834(%rip) + WORD $0x8949; BYTE $0xd0 // movq %rdx, %r8 -LBB27_22: +LBB23_15: + WORD $0x8545; BYTE $0xf6 // testl %r14d, %r14d + LONG $0x001a840f; WORD $0x0000 // je LBB23_18, $26(%rip) + WORD $0x894c; BYTE $0xd3 // movq %r10, %rbx + WORD $0x2948; BYTE $0xfb // subq %rdi, %rbx + LONG $0xd6bc0f41 // bsfl %r14d, %edx + WORD $0x0148; BYTE $0xda // addq %rbx, %rdx + LONG $0xfff88348 // cmpq $-1, %rax + LONG $0x031f850f; WORD $0x0000 // jne LBB23_70, $799(%rip) + WORD $0x8948; BYTE $0xd0 // movq %rdx, %rax + +LBB23_18: WORD $0x8545; BYTE $0xdb // testl %r11d, %r11d - LONG $0x0014840f; WORD $0x0000 // je LBB27_25, $20(%rip) - LONG $0xcbbc0f41 // bsfl %r11d, %ecx + LONG $0x001a840f; WORD $0x0000 // je LBB23_21, $26(%rip) + WORD $0x894c; BYTE $0xd3 // movq %r10, %rbx + WORD $0x2948; BYTE $0xfb // subq %rdi, %rbx + LONG $0xd3bc0f41 // bsfl %r11d, %edx + WORD $0x0148; BYTE $0xda // addq %rbx, %rdx LONG $0xfff98349 // cmpq $-1, %r9 - LONG $0x0323850f; WORD $0x0000 // jne LBB27_82, $803(%rip) - WORD $0x0148; BYTE $0xc1 // addq %rax, %rcx - WORD $0x8949; BYTE $0xc9 // movq %rcx, %r9 + LONG $0x02fc850f; WORD $0x0000 // jne LBB23_70, $764(%rip) + WORD $0x8949; BYTE $0xd1 // movq %rdx, %r9 -LBB27_25: - LONG $0x20fe8341 // cmpl $32, %r14d - LONG $0x021e850f; WORD $0x0000 // jne LBB27_83, $542(%rip) +LBB23_21: + WORD $0xf983; BYTE $0x20 // cmpl $32, %ecx + LONG $0x0213850f; WORD $0x0000 // jne LBB23_53, $531(%rip) + LONG $0x20c28349 // addq $32, %r10 LONG $0xe0c68348 // addq $-32, %rsi - LONG $0x20c08348 // addq $32, %rax LONG $0x1ffe8348 // cmpq $31, %rsi - LONG $0xfef8870f; WORD $0xffff // ja LBB27_9, $-264(%rip) + LONG $0xfeeb870f; WORD $0xffff // ja LBB23_7, $-277(%rip) WORD $0xf8c5; BYTE $0x77 // vzeroupper - WORD $0x0148; BYTE $0xf8 // addq %rdi, %rax - WORD $0x8949; BYTE $0xc6 // movq %rax, %r14 LONG $0x10fe8348 // cmpq $16, %rsi - LONG $0x014f820f; WORD $0x0000 // jb LBB27_49, $335(%rip) + LONG $0x014f820f; WORD $0x0000 // jb LBB23_41, $335(%rip) + +LBB23_24: + QUAD $0xfffffdb6056f79c5 // vmovdqa $-586(%rip), %xmm8 /* LCPI23_7(%rip) */ + QUAD $0xfffffdbe0d6f79c5 // vmovdqa $-578(%rip), %xmm9 /* LCPI23_8(%rip) */ + QUAD $0xfffffdc6156f79c5 // vmovdqa $-570(%rip), %xmm10 /* LCPI23_9(%rip) */ + QUAD $0xfffffdce1d6f79c5 // vmovdqa $-562(%rip), %xmm11 /* LCPI23_10(%rip) */ + QUAD $0xfffffdd6256ff9c5 // vmovdqa $-554(%rip), %xmm4 /* LCPI23_11(%rip) */ + QUAD $0xfffffdde2d6ff9c5 // vmovdqa $-546(%rip), %xmm5 /* LCPI23_12(%rip) */ + QUAD $0xfffffde6356ff9c5 // vmovdqa $-538(%rip), %xmm6 /* LCPI23_13(%rip) */ + LONG $0xffffbb41; WORD $0xffff // movl $4294967295, %r11d -LBB27_29: - WORD $0x894d; BYTE $0xf3 // movq %r14, %r11 - WORD $0x2949; BYTE $0xfb // subq %rdi, %r11 - WORD $0xc031 // xorl %eax, %eax - QUAD $0xfffffdb5056f79c5 // vmovdqa $-587(%rip), %xmm8 /* LCPI27_7(%rip) */ - QUAD $0xfffffdbd0d6f79c5 // vmovdqa $-579(%rip), %xmm9 /* LCPI27_8(%rip) */ - QUAD $0xfffffdc5156f79c5 // vmovdqa $-571(%rip), %xmm10 /* LCPI27_9(%rip) */ - QUAD $0xfffffdcd1d6ff9c5 // vmovdqa $-563(%rip), %xmm3 /* LCPI27_10(%rip) */ - QUAD $0xfffffdd5256ff9c5 // vmovdqa $-555(%rip), %xmm4 /* LCPI27_11(%rip) */ - QUAD $0xfffffddd2d6ff9c5 // vmovdqa $-547(%rip), %xmm5 /* LCPI27_12(%rip) */ - QUAD $0xfffffde5356ff9c5 // vmovdqa $-539(%rip), %xmm6 /* LCPI27_13(%rip) */ - LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 - -LBB27_30: - LONG $0x6f7ac1c4; WORD $0x063c // vmovdqu (%r14,%rax), %xmm7 - LONG $0xc774b9c5 // vpcmpeqb %xmm7, %xmm8, %xmm0 - LONG $0xcf74b1c5 // vpcmpeqb %xmm7, %xmm9, %xmm1 - LONG $0xc0ebf1c5 // vpor %xmm0, %xmm1, %xmm0 - LONG $0xcffca9c5 // vpaddb %xmm7, %xmm10, %xmm1 - LONG $0xd3daf1c5 // vpminub %xmm3, %xmm1, %xmm2 - LONG $0xca74f1c5 // vpcmpeqb %xmm2, %xmm1, %xmm1 + // .p2align 4, 0x90 +LBB23_25: + LONG $0x6f7ac1c4; BYTE $0x3a // vmovdqu (%r10), %xmm7 + LONG $0x6441c1c4; BYTE $0xc0 // vpcmpgtb %xmm8, %xmm7, %xmm0 + LONG $0xcf64b1c5 // vpcmpgtb %xmm7, %xmm9, %xmm1 + LONG $0xc1dbf9c5 // vpand %xmm1, %xmm0, %xmm0 + LONG $0xcf74a9c5 // vpcmpeqb %xmm7, %xmm10, %xmm1 + LONG $0xd774a1c5 // vpcmpeqb %xmm7, %xmm11, %xmm2 + LONG $0xc9ebe9c5 // vpor %xmm1, %xmm2, %xmm1 LONG $0xd4dbc1c5 // vpand %xmm4, %xmm7, %xmm2 LONG $0xd674e9c5 // vpcmpeqb %xmm6, %xmm2, %xmm2 LONG $0xfd74c1c5 // vpcmpeqb %xmm5, %xmm7, %xmm7 + LONG $0xdfebe9c5 // vpor %xmm7, %xmm2, %xmm3 + LONG $0xc0ebf1c5 // vpor %xmm0, %xmm1, %xmm0 + LONG $0xc0ebe1c5 // vpor %xmm0, %xmm3, %xmm0 LONG $0xd7d7f9c5 // vpmovmskb %xmm7, %edx - LONG $0xe2d779c5 // vpmovmskb %xmm2, %r12d - LONG $0xf8d779c5 // vpmovmskb %xmm0, %r15d - LONG $0xd7ebe9c5 // vpor %xmm7, %xmm2, %xmm2 - LONG $0xc0ebe9c5 // vpor %xmm0, %xmm2, %xmm0 - LONG $0xc1ebf9c5 // vpor %xmm1, %xmm0, %xmm0 + LONG $0xfad779c5 // vpmovmskb %xmm2, %r15d + LONG $0xf1d779c5 // vpmovmskb %xmm1, %r14d LONG $0xc8d7f9c5 // vpmovmskb %xmm0, %ecx - WORD $0xd1f7 // notl %ecx - WORD $0xbc0f; BYTE $0xc9 // bsfl %ecx, %ecx + WORD $0x314c; BYTE $0xd9 // xorq %r11, %rcx + LONG $0xc9bc0f48 // bsfq %rcx, %rcx WORD $0xf983; BYTE $0x10 // cmpl $16, %ecx - LONG $0x0014840f; WORD $0x0000 // je LBB27_32, $20(%rip) + LONG $0x0014840f; WORD $0x0000 // je LBB23_27, $20(%rip) LONG $0xffffffbb; BYTE $0xff // movl $-1, %ebx WORD $0xe3d3 // shll %cl, %ebx WORD $0xd3f7 // notl %ebx WORD $0xda21 // andl %ebx, %edx - WORD $0x2141; BYTE $0xdc // andl %ebx, %r12d - WORD $0x2144; BYTE $0xfb // andl %r15d, %ebx - WORD $0x8941; BYTE $0xdf // movl %ebx, %r15d + WORD $0x2141; BYTE $0xdf // andl %ebx, %r15d + WORD $0x2144; BYTE $0xf3 // andl %r14d, %ebx + WORD $0x8941; BYTE $0xde // movl %ebx, %r14d -LBB27_32: +LBB23_27: WORD $0x5a8d; BYTE $0xff // leal $-1(%rdx), %ebx WORD $0xd321 // andl %edx, %ebx - LONG $0x0243850f; WORD $0x0000 // jne LBB27_33, $579(%rip) - LONG $0x245c8d41; BYTE $0xff // leal $-1(%r12), %ebx - WORD $0x2144; BYTE $0xe3 // andl %r12d, %ebx - LONG $0x0235850f; WORD $0x0000 // jne LBB27_33, $565(%rip) + LONG $0x0215850f; WORD $0x0000 // jne LBB23_69, $533(%rip) LONG $0xff5f8d41 // leal $-1(%r15), %ebx WORD $0x2144; BYTE $0xfb // andl %r15d, %ebx - LONG $0x0228850f; WORD $0x0000 // jne LBB27_33, $552(%rip) + LONG $0x0208850f; WORD $0x0000 // jne LBB23_69, $520(%rip) + LONG $0xff5e8d41 // leal $-1(%r14), %ebx + WORD $0x2144; BYTE $0xf3 // andl %r14d, %ebx + LONG $0x01fb850f; WORD $0x0000 // jne LBB23_69, $507(%rip) WORD $0xd285 // testl %edx, %edx - LONG $0x0016840f; WORD $0x0000 // je LBB27_40, $22(%rip) + LONG $0x0019840f; WORD $0x0000 // je LBB23_33, $25(%rip) + WORD $0x894c; BYTE $0xd3 // movq %r10, %rbx + WORD $0x2948; BYTE $0xfb // subq %rdi, %rbx WORD $0xbc0f; BYTE $0xd2 // bsfl %edx, %edx - LONG $0xfffa8349 // cmpq $-1, %r10 - LONG $0x0223850f; WORD $0x0000 // jne LBB27_84, $547(%rip) - WORD $0x014c; BYTE $0xda // addq %r11, %rdx - WORD $0x0148; BYTE $0xc2 // addq %rax, %rdx - WORD $0x8949; BYTE $0xd2 // movq %rdx, %r10 - -LBB27_40: - WORD $0x8545; BYTE $0xe4 // testl %r12d, %r12d - LONG $0x0017840f; WORD $0x0000 // je LBB27_43, $23(%rip) - LONG $0xd4bc0f41 // bsfl %r12d, %edx + WORD $0x0148; BYTE $0xda // addq %rbx, %rdx LONG $0xfff88349 // cmpq $-1, %r8 - LONG $0x0203850f; WORD $0x0000 // jne LBB27_84, $515(%rip) - WORD $0x014c; BYTE $0xda // addq %r11, %rdx - WORD $0x0148; BYTE $0xc2 // addq %rax, %rdx + LONG $0x01e6850f; WORD $0x0000 // jne LBB23_70, $486(%rip) WORD $0x8949; BYTE $0xd0 // movq %rdx, %r8 -LBB27_43: +LBB23_33: WORD $0x8545; BYTE $0xff // testl %r15d, %r15d - LONG $0x0017840f; WORD $0x0000 // je LBB27_46, $23(%rip) + LONG $0x001a840f; WORD $0x0000 // je LBB23_36, $26(%rip) + WORD $0x894c; BYTE $0xd3 // movq %r10, %rbx + WORD $0x2948; BYTE $0xfb // subq %rdi, %rbx LONG $0xd7bc0f41 // bsfl %r15d, %edx + WORD $0x0148; BYTE $0xda // addq %rbx, %rdx + LONG $0xfff88348 // cmpq $-1, %rax + LONG $0x01c3850f; WORD $0x0000 // jne LBB23_70, $451(%rip) + WORD $0x8948; BYTE $0xd0 // movq %rdx, %rax + +LBB23_36: + WORD $0x8545; BYTE $0xf6 // testl %r14d, %r14d + LONG $0x001a840f; WORD $0x0000 // je LBB23_39, $26(%rip) + WORD $0x894c; BYTE $0xd3 // movq %r10, %rbx + WORD $0x2948; BYTE $0xfb // subq %rdi, %rbx + LONG $0xd6bc0f41 // bsfl %r14d, %edx + WORD $0x0148; BYTE $0xda // addq %rbx, %rdx LONG $0xfff98349 // cmpq $-1, %r9 - LONG $0x01e3850f; WORD $0x0000 // jne LBB27_84, $483(%rip) - WORD $0x014c; BYTE $0xda // addq %r11, %rdx - WORD $0x0148; BYTE $0xc2 // addq %rax, %rdx + LONG $0x01a0850f; WORD $0x0000 // jne LBB23_70, $416(%rip) WORD $0x8949; BYTE $0xd1 // movq %rdx, %r9 -LBB27_46: +LBB23_39: WORD $0xf983; BYTE $0x10 // cmpl $16, %ecx - LONG $0x00dd850f; WORD $0x0000 // jne LBB27_65, $221(%rip) + LONG $0x00d2850f; WORD $0x0000 // jne LBB23_54, $210(%rip) + LONG $0x10c28349 // addq $16, %r10 LONG $0xf0c68348 // addq $-16, %rsi - LONG $0x10c08348 // addq $16, %rax LONG $0x0ffe8348 // cmpq $15, %rsi - LONG $0xfef9870f; WORD $0xffff // ja LBB27_30, $-263(%rip) - WORD $0x0149; BYTE $0xc6 // addq %rax, %r14 + LONG $0xfeef870f; WORD $0xffff // ja LBB23_25, $-273(%rip) -LBB27_49: +LBB23_41: WORD $0x8548; BYTE $0xf6 // testq %rsi, %rsi - LONG $0x00c7840f; WORD $0x0000 // je LBB27_67, $199(%rip) - LONG $0x361c8d4d // leaq (%r14,%rsi), %r11 - WORD $0x894c; BYTE $0xf2 // movq %r14, %rdx - WORD $0x2948; BYTE $0xfa // subq %rdi, %rdx - WORD $0xc031 // xorl %eax, %eax - LONG $0xda3d8d4c; WORD $0x0001; BYTE $0x00 // leaq $474(%rip), %r15 /* LJTI27_0(%rip) */ - LONG $0x000031e9; BYTE $0x00 // jmp LBB27_51, $49(%rip) - -LBB27_53: - WORD $0xf983; BYTE $0x65 // cmpl $101, %ecx - LONG $0x00a3850f; WORD $0x0000 // jne LBB27_66, $163(%rip) + LONG $0x00ba840f; WORD $0x0000 // je LBB23_55, $186(%rip) + LONG $0x321c8d4d // leaq (%r10,%rsi), %r11 + LONG $0xbf1d8d48; WORD $0x0001; BYTE $0x00 // leaq $447(%rip), %rbx /* LJTI23_0(%rip) */ + LONG $0x000012e9; BYTE $0x00 // jmp LBB23_44, $18(%rip) + LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 -LBB27_54: - LONG $0xfff88349 // cmpq $-1, %r8 - LONG $0x0180850f; WORD $0x0000 // jne LBB27_59, $384(%rip) - LONG $0x02048d4c // leaq (%rdx,%rax), %r8 - QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 - -LBB27_63: - WORD $0xff48; BYTE $0xc0 // incq %rax - WORD $0x3948; BYTE $0xc6 // cmpq %rax, %rsi - LONG $0x012d840f; WORD $0x0000 // je LBB27_64, $301(%rip) - -LBB27_51: - LONG $0x0cbe0f41; BYTE $0x06 // movsbl (%r14,%rax), %ecx - WORD $0x598d; BYTE $0xd0 // leal $-48(%rcx), %ebx - WORD $0xfb83; BYTE $0x0a // cmpl $10, %ebx - LONG $0xffe3820f; WORD $0xffff // jb LBB27_63, $-29(%rip) - WORD $0x598d; BYTE $0xd5 // leal $-43(%rcx), %ebx - WORD $0xfb83; BYTE $0x1a // cmpl $26, %ebx - LONG $0xffb2870f; WORD $0xffff // ja LBB27_53, $-78(%rip) - LONG $0x9f0c6349 // movslq (%r15,%rbx,4), %rcx - WORD $0x014c; BYTE $0xf9 // addq %r15, %rcx - JMP CX +LBB23_43: + WORD $0x8949; BYTE $0xca // movq %rcx, %r10 + WORD $0xff48; BYTE $0xce // decq %rsi + LONG $0x0167840f; WORD $0x0000 // je LBB23_73, $359(%rip) -LBB27_61: +LBB23_44: + LONG $0x12be0f41 // movsbl (%r10), %edx + WORD $0xc283; BYTE $0xd5 // addl $-43, %edx + WORD $0xfa83; BYTE $0x3a // cmpl $58, %edx + LONG $0x0088870f; WORD $0x0000 // ja LBB23_55, $136(%rip) + LONG $0x014a8d49 // leaq $1(%r10), %rcx + LONG $0x93146348 // movslq (%rbx,%rdx,4), %rdx + WORD $0x0148; BYTE $0xda // addq %rbx, %rdx + JMP DX + +LBB23_46: + WORD $0x8948; BYTE $0xca // movq %rcx, %rdx + WORD $0x2948; BYTE $0xfa // subq %rdi, %rdx LONG $0xfff98349 // cmpq $-1, %r9 - LONG $0x0132850f; WORD $0x0000 // jne LBB27_59, $306(%rip) - LONG $0x020c8d4c // leaq (%rdx,%rax), %r9 - LONG $0xffffbbe9; BYTE $0xff // jmp LBB27_63, $-69(%rip) + LONG $0x0152850f; WORD $0x0000 // jne LBB23_77, $338(%rip) + WORD $0xff48; BYTE $0xca // decq %rdx + WORD $0x8949; BYTE $0xd1 // movq %rdx, %r9 + LONG $0xffffbce9; BYTE $0xff // jmp LBB23_43, $-68(%rip) -LBB27_57: - LONG $0xfffa8349 // cmpq $-1, %r10 - LONG $0x011f850f; WORD $0x0000 // jne LBB27_59, $287(%rip) - LONG $0x02148d4c // leaq (%rdx,%rax), %r10 - LONG $0xffffa8e9; BYTE $0xff // jmp LBB27_63, $-88(%rip) +LBB23_48: + WORD $0x8948; BYTE $0xca // movq %rcx, %rdx + WORD $0x2948; BYTE $0xfa // subq %rdi, %rdx + LONG $0xfff88348 // cmpq $-1, %rax + LONG $0x0137850f; WORD $0x0000 // jne LBB23_77, $311(%rip) + WORD $0xff48; BYTE $0xca // decq %rdx + WORD $0x8948; BYTE $0xd0 // movq %rdx, %rax + LONG $0xffffa1e9; BYTE $0xff // jmp LBB23_43, $-95(%rip) -LBB27_1: - LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax - LONG $0x000120e9; BYTE $0x00 // jmp LBB27_81, $288(%rip) +LBB23_50: + WORD $0x8948; BYTE $0xca // movq %rcx, %rdx + WORD $0x2948; BYTE $0xfa // subq %rdi, %rdx + LONG $0xfff88349 // cmpq $-1, %r8 + LONG $0x011c850f; WORD $0x0000 // jne LBB23_77, $284(%rip) + WORD $0xff48; BYTE $0xca // decq %rdx + WORD $0x8949; BYTE $0xd0 // movq %rdx, %r8 + LONG $0xffff86e9; BYTE $0xff // jmp LBB23_43, $-122(%rip) -LBB27_83: - WORD $0x0149; BYTE $0xc6 // addq %rax, %r14 - WORD $0x0149; BYTE $0xfe // addq %rdi, %r14 - WORD $0xf8c5; BYTE $0x77 // vzeroupper +LBB23_52: LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax - WORD $0x854d; BYTE $0xd2 // testq %r10, %r10 - LONG $0x001d850f; WORD $0x0000 // jne LBB27_68, $29(%rip) - LONG $0x000102e9; BYTE $0x00 // jmp LBB27_81, $258(%rip) + LONG $0x0000e3e9; BYTE $0x00 // jmp LBB23_72, $227(%rip) -LBB27_65: - WORD $0xc989 // movl %ecx, %ecx - WORD $0x0149; BYTE $0xce // addq %rcx, %r14 +LBB23_53: + WORD $0x0149; BYTE $0xca // addq %rcx, %r10 + WORD $0xf8c5; BYTE $0x77 // vzeroupper + LONG $0xffc2c748; WORD $0xffff; BYTE $0xff // movq $-1, %rdx + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0x0018850f; WORD $0x0000 // jne LBB23_56, $24(%rip) + LONG $0x0000c5e9; BYTE $0x00 // jmp LBB23_71, $197(%rip) -LBB27_66: - WORD $0x0149; BYTE $0xc6 // addq %rax, %r14 +LBB23_54: + WORD $0x0149; BYTE $0xca // addq %rcx, %r10 -LBB27_67: - LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax - WORD $0x854d; BYTE $0xd2 // testq %r10, %r10 - LONG $0x00ea840f; WORD $0x0000 // je LBB27_81, $234(%rip) +LBB23_55: + LONG $0xffc2c748; WORD $0xffff; BYTE $0xff // movq $-1, %rdx + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0x00b2840f; WORD $0x0000 // je LBB23_71, $178(%rip) -LBB27_68: +LBB23_56: WORD $0x854d; BYTE $0xc9 // testq %r9, %r9 - LONG $0x00e1840f; WORD $0x0000 // je LBB27_81, $225(%rip) + LONG $0x00a9840f; WORD $0x0000 // je LBB23_71, $169(%rip) WORD $0x854d; BYTE $0xc0 // testq %r8, %r8 - LONG $0x00d8840f; WORD $0x0000 // je LBB27_81, $216(%rip) - WORD $0x2949; BYTE $0xfe // subq %rdi, %r14 - LONG $0xff468d49 // leaq $-1(%r14), %rax - WORD $0x3949; BYTE $0xc2 // cmpq %rax, %r10 - LONG $0x0033840f; WORD $0x0000 // je LBB27_73, $51(%rip) - WORD $0x3949; BYTE $0xc1 // cmpq %rax, %r9 - LONG $0x002a840f; WORD $0x0000 // je LBB27_73, $42(%rip) - WORD $0x3949; BYTE $0xc0 // cmpq %rax, %r8 - LONG $0x0021840f; WORD $0x0000 // je LBB27_73, $33(%rip) + LONG $0x00a0840f; WORD $0x0000 // je LBB23_71, $160(%rip) + WORD $0x2949; BYTE $0xfa // subq %rdi, %r10 + LONG $0xff4a8d49 // leaq $-1(%r10), %rcx + WORD $0x3948; BYTE $0xc8 // cmpq %rcx, %rax + LONG $0x0036840f; WORD $0x0000 // je LBB23_64, $54(%rip) + WORD $0x3949; BYTE $0xc8 // cmpq %rcx, %r8 + LONG $0x002d840f; WORD $0x0000 // je LBB23_64, $45(%rip) + WORD $0x3949; BYTE $0xc9 // cmpq %rcx, %r9 + LONG $0x0024840f; WORD $0x0000 // je LBB23_64, $36(%rip) WORD $0x854d; BYTE $0xc9 // testq %r9, %r9 - LONG $0x00238e0f; WORD $0x0000 // jle LBB27_77, $35(%rip) - LONG $0xff418d49 // leaq $-1(%r9), %rax - WORD $0x3949; BYTE $0xc0 // cmpq %rax, %r8 - LONG $0x0016840f; WORD $0x0000 // je LBB27_77, $22(%rip) + LONG $0x00298e0f; WORD $0x0000 // jle LBB23_65, $41(%rip) + LONG $0xff498d49 // leaq $-1(%r9), %rcx + WORD $0x3948; BYTE $0xc8 // cmpq %rcx, %rax + LONG $0x001c840f; WORD $0x0000 // je LBB23_65, $28(%rip) WORD $0xf749; BYTE $0xd1 // notq %r9 + WORD $0x894c; BYTE $0xca // movq %r9, %rdx WORD $0x894c; BYTE $0xc8 // movq %r9, %rax - LONG $0x000095e9; BYTE $0x00 // jmp LBB27_81, $149(%rip) + LONG $0x00005de9; BYTE $0x00 // jmp LBB23_72, $93(%rip) -LBB27_73: - WORD $0xf749; BYTE $0xde // negq %r14 - WORD $0x894c; BYTE $0xf0 // movq %r14, %rax - LONG $0x00008ae9; BYTE $0x00 // jmp LBB27_81, $138(%rip) +LBB23_64: + WORD $0xf749; BYTE $0xda // negq %r10 + WORD $0x894c; BYTE $0xd2 // movq %r10, %rdx + WORD $0x894c; BYTE $0xd0 // movq %r10, %rax + LONG $0x00004fe9; BYTE $0x00 // jmp LBB23_72, $79(%rip) -LBB27_77: - WORD $0x894c; BYTE $0xd0 // movq %r10, %rax - WORD $0x094c; BYTE $0xc0 // orq %r8, %rax - WORD $0x990f; BYTE $0xc0 // setns %al - LONG $0x0014880f; WORD $0x0000 // js LBB27_80, $20(%rip) - WORD $0x394d; BYTE $0xc2 // cmpq %r8, %r10 - LONG $0x000b8c0f; WORD $0x0000 // jl LBB27_80, $11(%rip) - WORD $0xf749; BYTE $0xd2 // notq %r10 - WORD $0x894c; BYTE $0xd0 // movq %r10, %rax - LONG $0x000067e9; BYTE $0x00 // jmp LBB27_81, $103(%rip) - -LBB27_80: - LONG $0xff488d49 // leaq $-1(%r8), %rcx - WORD $0x3949; BYTE $0xca // cmpq %rcx, %r10 - WORD $0xf749; BYTE $0xd0 // notq %r8 - LONG $0xc6450f4d // cmovneq %r14, %r8 - WORD $0xc084 // testb %al, %al - LONG $0xc6440f4d // cmoveq %r14, %r8 - WORD $0x894c; BYTE $0xc0 // movq %r8, %rax - LONG $0x00004be9; BYTE $0x00 // jmp LBB27_81, $75(%rip) - -LBB27_64: - WORD $0x894d; BYTE $0xde // movq %r11, %r14 - LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax - WORD $0x854d; BYTE $0xd2 // testq %r10, %r10 - LONG $0xff4e850f; WORD $0xffff // jne LBB27_68, $-178(%rip) - LONG $0x000033e9; BYTE $0x00 // jmp LBB27_81, $51(%rip) - -LBB27_12: - WORD $0xbc0f; BYTE $0xc9 // bsfl %ecx, %ecx - LONG $0x000002e9; BYTE $0x00 // jmp LBB27_13, $2(%rip) - -LBB27_82: - WORD $0xc989 // movl %ecx, %ecx +LBB23_65: + WORD $0x894c; BYTE $0xc1 // movq %r8, %rcx + WORD $0x0948; BYTE $0xc1 // orq %rax, %rcx + WORD $0x3949; BYTE $0xc0 // cmpq %rax, %r8 + LONG $0x00178c0f; WORD $0x0000 // jl LBB23_68, $23(%rip) + WORD $0x8548; BYTE $0xc9 // testq %rcx, %rcx + LONG $0x000e880f; WORD $0x0000 // js LBB23_68, $14(%rip) + WORD $0xf749; BYTE $0xd0 // notq %r8 + WORD $0x894c; BYTE $0xc2 // movq %r8, %rdx + WORD $0x894c; BYTE $0xc0 // movq %r8, %rax + LONG $0x000029e9; BYTE $0x00 // jmp LBB23_72, $41(%rip) -LBB27_13: +LBB23_68: + LONG $0xff508d48 // leaq $-1(%rax), %rdx + WORD $0x8548; BYTE $0xc9 // testq %rcx, %rcx WORD $0xf748; BYTE $0xd0 // notq %rax - WORD $0x2948; BYTE $0xc8 // subq %rcx, %rax - LONG $0x00001ee9; BYTE $0x00 // jmp LBB27_81, $30(%rip) - -LBB27_33: - WORD $0xbc0f; BYTE $0xcb // bsfl %ebx, %ecx - LONG $0x00000ae9; BYTE $0x00 // jmp LBB27_34, $10(%rip) - -LBB27_59: - WORD $0x294c; BYTE $0xf7 // subq %r14, %rdi - LONG $0x000008e9; BYTE $0x00 // jmp LBB27_60, $8(%rip) + LONG $0xc2480f49 // cmovsq %r10, %rax + WORD $0x3949; BYTE $0xd0 // cmpq %rdx, %r8 + LONG $0xc2450f49 // cmovneq %r10, %rax + LONG $0x00000fe9; BYTE $0x00 // jmp LBB23_72, $15(%rip) -LBB27_84: - WORD $0xd189 // movl %edx, %ecx +LBB23_69: + WORD $0x2949; BYTE $0xfa // subq %rdi, %r10 + WORD $0xbc0f; BYTE $0xd3 // bsfl %ebx, %edx + WORD $0x014c; BYTE $0xd2 // addq %r10, %rdx -LBB27_34: - WORD $0x294c; BYTE $0xf7 // subq %r14, %rdi - WORD $0x2948; BYTE $0xcf // subq %rcx, %rdi +LBB23_70: + WORD $0xf748; BYTE $0xd2 // notq %rdx -LBB27_60: - WORD $0xf748; BYTE $0xd0 // notq %rax - WORD $0x0148; BYTE $0xf8 // addq %rdi, %rax +LBB23_71: + WORD $0x8948; BYTE $0xd0 // movq %rdx, %rax -LBB27_81: +LBB23_72: BYTE $0x5b // popq %rbx - WORD $0x5c41 // popq %r12 WORD $0x5e41 // popq %r14 WORD $0x5f41 // popq %r15 BYTE $0x5d // popq %rbp WORD $0xf8c5; BYTE $0x77 // vzeroupper BYTE $0xc3 // retq -LBB27_7: +LBB23_73: + WORD $0x894d; BYTE $0xda // movq %r11, %r10 + LONG $0xffc2c748; WORD $0xffff; BYTE $0xff // movq $-1, %rdx + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0xff2e850f; WORD $0xffff // jne LBB23_56, $-210(%rip) + LONG $0xffffdbe9; BYTE $0xff // jmp LBB23_71, $-37(%rip) + +LBB23_77: + WORD $0xf748; BYTE $0xda // negq %rdx + LONG $0xffffd3e9; BYTE $0xff // jmp LBB23_71, $-45(%rip) + +LBB23_74: + LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax LONG $0xffc0c749; WORD $0xffff; BYTE $0xff // movq $-1, %r8 - LONG $0xffc2c749; WORD $0xffff; BYTE $0xff // movq $-1, %r10 - WORD $0x8949; BYTE $0xfe // movq %rdi, %r14 + WORD $0x8949; BYTE $0xfa // movq %rdi, %r10 LONG $0x10fe8348 // cmpq $16, %rsi - LONG $0xfcc0830f; WORD $0xffff // jae LBB27_29, $-832(%rip) - LONG $0xfffe0ae9; BYTE $0xff // jmp LBB27_49, $-502(%rip) - - // .p2align 2, 0x90 - // .set L27_0_set_61, LBB27_61-LJTI27_0 - // .set L27_0_set_66, LBB27_66-LJTI27_0 - // .set L27_0_set_57, LBB27_57-LJTI27_0 - // .set L27_0_set_54, LBB27_54-LJTI27_0 -LJTI27_0: - LONG $0xfffffe82 // .long L27_0_set_61 - LONG $0xfffffed7 // .long L27_0_set_66 - LONG $0xfffffe82 // .long L27_0_set_61 - LONG $0xfffffe95 // .long L27_0_set_57 - LONG $0xfffffed7 // .long L27_0_set_66 - LONG $0xfffffed7 // .long L27_0_set_66 - LONG $0xfffffed7 // .long L27_0_set_66 - LONG $0xfffffed7 // .long L27_0_set_66 - LONG $0xfffffed7 // .long L27_0_set_66 - LONG $0xfffffed7 // .long L27_0_set_66 - LONG $0xfffffed7 // .long L27_0_set_66 - LONG $0xfffffed7 // .long L27_0_set_66 - LONG $0xfffffed7 // .long L27_0_set_66 - LONG $0xfffffed7 // .long L27_0_set_66 - LONG $0xfffffed7 // .long L27_0_set_66 - LONG $0xfffffed7 // .long L27_0_set_66 - LONG $0xfffffed7 // .long L27_0_set_66 - LONG $0xfffffed7 // .long L27_0_set_66 - LONG $0xfffffed7 // .long L27_0_set_66 - LONG $0xfffffed7 // .long L27_0_set_66 - LONG $0xfffffed7 // .long L27_0_set_66 - LONG $0xfffffed7 // .long L27_0_set_66 - LONG $0xfffffed7 // .long L27_0_set_66 - LONG $0xfffffed7 // .long L27_0_set_66 - LONG $0xfffffed7 // .long L27_0_set_66 - LONG $0xfffffed7 // .long L27_0_set_66 - LONG $0xfffffe34 // .long L27_0_set_54 - LONG $0x90909090 // .p2align 4, 0x90 + LONG $0xfce4830f; WORD $0xffff // jae LBB23_24, $-796(%rip) + LONG $0xfffe2ee9; BYTE $0xff // jmp LBB23_41, $-466(%rip) + BYTE $0x90 // .p2align 2, 0x90 + + // .set L23_0_set_46, LBB23_46-LJTI23_0 + // .set L23_0_set_55, LBB23_55-LJTI23_0 + // .set L23_0_set_50, LBB23_50-LJTI23_0 + // .set L23_0_set_43, LBB23_43-LJTI23_0 + // .set L23_0_set_48, LBB23_48-LJTI23_0 +LJTI23_0: + LONG $0xfffffe75 // .long L23_0_set_46 + LONG $0xfffffef0 // .long L23_0_set_55 + LONG $0xfffffe75 // .long L23_0_set_46 + LONG $0xfffffeab // .long L23_0_set_50 + LONG $0xfffffef0 // .long L23_0_set_55 + LONG $0xfffffe4c // .long L23_0_set_43 + LONG $0xfffffe4c // .long L23_0_set_43 + LONG $0xfffffe4c // .long L23_0_set_43 + LONG $0xfffffe4c // .long L23_0_set_43 + LONG $0xfffffe4c // .long L23_0_set_43 + LONG $0xfffffe4c // .long L23_0_set_43 + LONG $0xfffffe4c // .long L23_0_set_43 + LONG $0xfffffe4c // .long L23_0_set_43 + LONG $0xfffffe4c // .long L23_0_set_43 + LONG $0xfffffe4c // .long L23_0_set_43 + LONG $0xfffffef0 // .long L23_0_set_55 + LONG $0xfffffef0 // .long L23_0_set_55 + LONG $0xfffffef0 // .long L23_0_set_55 + LONG $0xfffffef0 // .long L23_0_set_55 + LONG $0xfffffef0 // .long L23_0_set_55 + LONG $0xfffffef0 // .long L23_0_set_55 + LONG $0xfffffef0 // .long L23_0_set_55 + LONG $0xfffffef0 // .long L23_0_set_55 + LONG $0xfffffef0 // .long L23_0_set_55 + LONG $0xfffffef0 // .long L23_0_set_55 + LONG $0xfffffef0 // .long L23_0_set_55 + LONG $0xfffffe90 // .long L23_0_set_48 + LONG $0xfffffef0 // .long L23_0_set_55 + LONG $0xfffffef0 // .long L23_0_set_55 + LONG $0xfffffef0 // .long L23_0_set_55 + LONG $0xfffffef0 // .long L23_0_set_55 + LONG $0xfffffef0 // .long L23_0_set_55 + LONG $0xfffffef0 // .long L23_0_set_55 + LONG $0xfffffef0 // .long L23_0_set_55 + LONG $0xfffffef0 // .long L23_0_set_55 + LONG $0xfffffef0 // .long L23_0_set_55 + LONG $0xfffffef0 // .long L23_0_set_55 + LONG $0xfffffef0 // .long L23_0_set_55 + LONG $0xfffffef0 // .long L23_0_set_55 + LONG $0xfffffef0 // .long L23_0_set_55 + LONG $0xfffffef0 // .long L23_0_set_55 + LONG $0xfffffef0 // .long L23_0_set_55 + LONG $0xfffffef0 // .long L23_0_set_55 + LONG $0xfffffef0 // .long L23_0_set_55 + LONG $0xfffffef0 // .long L23_0_set_55 + LONG $0xfffffef0 // .long L23_0_set_55 + LONG $0xfffffef0 // .long L23_0_set_55 + LONG $0xfffffef0 // .long L23_0_set_55 + LONG $0xfffffef0 // .long L23_0_set_55 + LONG $0xfffffef0 // .long L23_0_set_55 + LONG $0xfffffef0 // .long L23_0_set_55 + LONG $0xfffffef0 // .long L23_0_set_55 + LONG $0xfffffef0 // .long L23_0_set_55 + LONG $0xfffffef0 // .long L23_0_set_55 + LONG $0xfffffef0 // .long L23_0_set_55 + LONG $0xfffffef0 // .long L23_0_set_55 + LONG $0xfffffef0 // .long L23_0_set_55 + LONG $0xfffffef0 // .long L23_0_set_55 + LONG $0xfffffe90 // .long L23_0_set_48 + // .p2align 4, 0x90 _skip_positive: BYTE $0x55 // pushq %rbp WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp @@ -7685,28 +7215,27 @@ _skip_positive: LONG $0x08778b48 // movq $8(%rdi), %rsi WORD $0x2948; BYTE $0xde // subq %rbx, %rsi WORD $0x8948; BYTE $0xc7 // movq %rax, %rdi - LONG $0xfffa5be8; BYTE $0xff // callq _do_skip_number, $-1445(%rip) + LONG $0xfff9fbe8; BYTE $0xff // callq _do_skip_number, $-1541(%rip) WORD $0x8548; BYTE $0xc0 // testq %rax, %rax - LONG $0x000e880f; WORD $0x0000 // js LBB28_1, $14(%rip) + LONG $0x000d880f; WORD $0x0000 // js LBB24_1, $13(%rip) WORD $0x8b49; BYTE $0x0e // movq (%r14), %rcx - WORD $0x0148; BYTE $0xc1 // addq %rax, %rcx - WORD $0xff48; BYTE $0xc9 // decq %rcx - LONG $0x000011e9; BYTE $0x00 // jmp LBB28_3, $17(%rip) + LONG $0x084c8d48; BYTE $0xff // leaq $-1(%rax,%rcx), %rcx + LONG $0x000011e9; BYTE $0x00 // jmp LBB24_3, $17(%rip) -LBB28_1: +LBB24_1: WORD $0x8b49; BYTE $0x0e // movq (%r14), %rcx WORD $0x2948; BYTE $0xc1 // subq %rax, %rcx LONG $0xfec18348 // addq $-2, %rcx LONG $0xfec3c748; WORD $0xffff; BYTE $0xff // movq $-2, %rbx -LBB28_3: - WORD $0x8949; BYTE $0x0e // movq %rcx, (%r14) - WORD $0x8948; BYTE $0xd8 // movq %rbx, %rax - BYTE $0x5b // popq %rbx - WORD $0x5e41 // popq %r14 - BYTE $0x5d // popq %rbp - BYTE $0xc3 // retq - QUAD $0x9090909090909090 // .p2align 4, 0x90 +LBB24_3: + WORD $0x8949; BYTE $0x0e // movq %rcx, (%r14) + WORD $0x8948; BYTE $0xd8 // movq %rbx, %rax + BYTE $0x5b // popq %rbx + WORD $0x5e41 // popq %r14 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90 _skip_number: BYTE $0x55 // pushq %rbp @@ -7725,22 +7254,22 @@ _skip_number: WORD $0x940f; BYTE $0xc0 // sete %al WORD $0x0148; BYTE $0xc3 // addq %rax, %rbx WORD $0x2948; BYTE $0xc6 // subq %rax, %rsi - LONG $0x003c840f; WORD $0x0000 // je LBB29_6, $60(%rip) + LONG $0x003b840f; WORD $0x0000 // je LBB25_6, $59(%rip) WORD $0x3949; BYTE $0xf7 // cmpq %rsi, %r15 - LONG $0x000d830f; WORD $0x0000 // jae LBB29_3, $13(%rip) - WORD $0xb60f; BYTE $0x03 // movzbl (%rbx), %eax - WORD $0xc604 // addb $-58, %al - WORD $0xf63c // cmpb $-10, %al - LONG $0x0038820f; WORD $0x0000 // jb LBB29_8, $56(%rip) + LONG $0x000c830f; WORD $0x0000 // jae LBB25_3, $12(%rip) + WORD $0x038a // movb (%rbx), %al + WORD $0xd004 // addb $-48, %al + WORD $0x093c // cmpb $9, %al + LONG $0x0038870f; WORD $0x0000 // ja LBB25_8, $56(%rip) -LBB29_3: +LBB25_3: WORD $0x8948; BYTE $0xdf // movq %rbx, %rdi - LONG $0xfff9d0e8; BYTE $0xff // callq _do_skip_number, $-1584(%rip) + LONG $0xfff971e8; BYTE $0xff // callq _do_skip_number, $-1679(%rip) WORD $0x8548; BYTE $0xc0 // testq %rax, %rax - LONG $0x0021880f; WORD $0x0000 // js LBB29_7, $33(%rip) + LONG $0x0021880f; WORD $0x0000 // js LBB25_7, $33(%rip) WORD $0x0148; BYTE $0xc3 // addq %rax, %rbx -LBB29_5: +LBB25_5: WORD $0x294c; BYTE $0xe3 // subq %r12, %rbx WORD $0x8949; BYTE $0x1e // movq %rbx, (%r14) WORD $0x894c; BYTE $0xf8 // movq %r15, %rax @@ -7751,20 +7280,20 @@ LBB29_5: BYTE $0x5d // popq %rbp BYTE $0xc3 // retq -LBB29_6: +LBB25_6: LONG $0xffc7c749; WORD $0xffff; BYTE $0xff // movq $-1, %r15 - LONG $0xffffe2e9; BYTE $0xff // jmp LBB29_5, $-30(%rip) + LONG $0xffffe2e9; BYTE $0xff // jmp LBB25_5, $-30(%rip) -LBB29_7: +LBB25_7: WORD $0xf748; BYTE $0xd0 // notq %rax WORD $0x0148; BYTE $0xc3 // addq %rax, %rbx -LBB29_8: +LBB25_8: LONG $0xfec7c749; WORD $0xffff; BYTE $0xff // movq $-2, %r15 - LONG $0xffffd0e9; BYTE $0xff // jmp LBB29_5, $-48(%rip) - LONG $0x00000000 // .p2align 4, 0x00 + LONG $0xffffd0e9; BYTE $0xff // jmp LBB25_5, $-48(%rip) + LONG $0x00000000; BYTE $0x00 // .p2align 4, 0x00 -LCPI30_0: +LCPI26_0: LONG $0x00000001 // .long 1 LONG $0x00000000 // .long 0 LONG $0x00000000 // .long 0 @@ -7777,14 +7306,14 @@ _skip_one: WORD $0x8948; BYTE $0xd0 // movq %rdx, %rax WORD $0x8948; BYTE $0xf2 // movq %rsi, %rdx WORD $0x8948; BYTE $0xfe // movq %rdi, %rsi - QUAD $0xffffffdb0528f8c5 // vmovaps $-37(%rip), %xmm0 /* LCPI30_0(%rip) */ + QUAD $0xffffffdb0528f8c5 // vmovaps $-37(%rip), %xmm0 /* LCPI26_0(%rip) */ LONG $0x0011f8c5 // vmovups %xmm0, (%rax) WORD $0x8948; BYTE $0xc7 // movq %rax, %rdi BYTE $0x5d // popq %rbp - LONG $0xffef8ee9; BYTE $0xff // jmp _fsm_exec, $-4210(%rip) + LONG $0xffeeeee9; BYTE $0xff // jmp _fsm_exec, $-4370(%rip) QUAD $0x0000000000000000; LONG $0x00000000; WORD $0x0000 // .p2align 4, 0x00 -LCPI31_0: +LCPI27_0: LONG $0x00000001 // .long 1 LONG $0x00000000 // .long 0 LONG $0x00000000 // .long 0 @@ -7797,54 +7326,54 @@ _validate_one: WORD $0x8948; BYTE $0xd0 // movq %rdx, %rax WORD $0x8948; BYTE $0xf2 // movq %rsi, %rdx WORD $0x8948; BYTE $0xfe // movq %rdi, %rsi - QUAD $0xffffffdb0528f8c5 // vmovaps $-37(%rip), %xmm0 /* LCPI31_0(%rip) */ + QUAD $0xffffffdb0528f8c5 // vmovaps $-37(%rip), %xmm0 /* LCPI27_0(%rip) */ LONG $0x0011f8c5 // vmovups %xmm0, (%rax) LONG $0x000020b9; BYTE $0x00 // movl $32, %ecx WORD $0x8948; BYTE $0xc7 // movq %rax, %rdi BYTE $0x5d // popq %rbp - LONG $0xffef49e9; BYTE $0xff // jmp _fsm_exec, $-4279(%rip) + LONG $0xffeea9e9; BYTE $0xff // jmp _fsm_exec, $-4439(%rip) QUAD $0x0000000000000000; BYTE $0x00 // .p2align 5, 0x00 -LCPI32_0: +LCPI28_0: QUAD $0x2c2c2c2c2c2c2c2c; QUAD $0x2c2c2c2c2c2c2c2c // .space 16, ',,,,,,,,,,,,,,,,' QUAD $0x2c2c2c2c2c2c2c2c; QUAD $0x2c2c2c2c2c2c2c2c // .space 16, ',,,,,,,,,,,,,,,,' -LCPI32_1: +LCPI28_1: QUAD $0xdfdfdfdfdfdfdfdf; QUAD $0xdfdfdfdfdfdfdfdf // .space 16, '\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf' QUAD $0xdfdfdfdfdfdfdfdf; QUAD $0xdfdfdfdfdfdfdfdf // .space 16, '\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf' -LCPI32_2: +LCPI28_2: QUAD $0x5d5d5d5d5d5d5d5d; QUAD $0x5d5d5d5d5d5d5d5d // .space 16, ']]]]]]]]]]]]]]]]' QUAD $0x5d5d5d5d5d5d5d5d; QUAD $0x5d5d5d5d5d5d5d5d // .space 16, ']]]]]]]]]]]]]]]]' -LCPI32_6: +LCPI28_6: QUAD $0x2222222222222222; QUAD $0x2222222222222222 // .space 16, '""""""""""""""""' QUAD $0x2222222222222222; QUAD $0x2222222222222222 // .space 16, '""""""""""""""""' -LCPI32_7: +LCPI28_7: QUAD $0x5c5c5c5c5c5c5c5c; QUAD $0x5c5c5c5c5c5c5c5c // .space 16, '\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' QUAD $0x5c5c5c5c5c5c5c5c; QUAD $0x5c5c5c5c5c5c5c5c // .space 16, '\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' -LCPI32_8: +LCPI28_8: QUAD $0x7b7b7b7b7b7b7b7b; QUAD $0x7b7b7b7b7b7b7b7b // .space 16, '{{{{{{{{{{{{{{{{' QUAD $0x7b7b7b7b7b7b7b7b; QUAD $0x7b7b7b7b7b7b7b7b // .space 16, '{{{{{{{{{{{{{{{{' -LCPI32_9: +LCPI28_9: QUAD $0x7d7d7d7d7d7d7d7d; QUAD $0x7d7d7d7d7d7d7d7d // .space 16, '}}}}}}}}}}}}}}}}' QUAD $0x7d7d7d7d7d7d7d7d; QUAD $0x7d7d7d7d7d7d7d7d // .space 16, '}}}}}}}}}}}}}}}}' -LCPI32_10: +LCPI28_10: QUAD $0x5b5b5b5b5b5b5b5b; QUAD $0x5b5b5b5b5b5b5b5b // .space 16, '[[[[[[[[[[[[[[[[' QUAD $0x5b5b5b5b5b5b5b5b; QUAD $0x5b5b5b5b5b5b5b5b // .space 16, '[[[[[[[[[[[[[[[[' // .p2align 4, 0x00 -LCPI32_3: +LCPI28_3: QUAD $0x2c2c2c2c2c2c2c2c; QUAD $0x2c2c2c2c2c2c2c2c // .space 16, ',,,,,,,,,,,,,,,,' -LCPI32_4: +LCPI28_4: QUAD $0xdfdfdfdfdfdfdfdf; QUAD $0xdfdfdfdfdfdfdfdf // .space 16, '\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf' -LCPI32_5: +LCPI28_5: QUAD $0x5d5d5d5d5d5d5d5d; QUAD $0x5d5d5d5d5d5d5d5d // .space 16, ']]]]]]]]]]]]]]]]' // .p2align 4, 0x90 @@ -7860,111 +7389,104 @@ _skip_one_fast: LONG $0x80ec8148; WORD $0x0000; BYTE $0x00 // subq $128, %rsp WORD $0x8949; BYTE $0xf6 // movq %rsi, %r14 WORD $0x8949; BYTE $0xff // movq %rdi, %r15 - LONG $0xffdccde8; BYTE $0xff // callq _advance_ns, $-9011(%rip) + WORD $0x8b48; BYTE $0x3f // movq (%rdi), %rdi + LONG $0x08778b49 // movq $8(%r15), %rsi + WORD $0x894c; BYTE $0xf2 // movq %r14, %rdx + LONG $0xffdd03e8; BYTE $0xff // callq _advance_ns, $-8957(%rip) WORD $0x8b49; BYTE $0x16 // movq (%r14), %rdx LONG $0xff628d4c // leaq $-1(%rdx), %r12 WORD $0xbe0f; BYTE $0xc8 // movsbl %al, %ecx WORD $0xf983; BYTE $0x7b // cmpl $123, %ecx - LONG $0x0176870f; WORD $0x0000 // ja LBB32_23, $374(%rip) + LONG $0x015d870f; WORD $0x0000 // ja LBB28_23, $349(%rip) LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax - LONG $0x04358d48; WORD $0x0009; BYTE $0x00 // leaq $2308(%rip), %rsi /* LJTI32_0(%rip) */ + LONG $0xc6358d48; WORD $0x0008; BYTE $0x00 // leaq $2246(%rip), %rsi /* LJTI28_0(%rip) */ LONG $0x8e0c6348 // movslq (%rsi,%rcx,4), %rcx WORD $0x0148; BYTE $0xf1 // addq %rsi, %rcx JMP CX -LBB32_2: - WORD $0x8b49; BYTE $0x07 // movq (%r15), %rax - LONG $0x08778b49 // movq $8(%r15), %rsi - WORD $0x8948; BYTE $0xf1 // movq %rsi, %rcx - WORD $0x2948; BYTE $0xd1 // subq %rdx, %rcx - LONG $0x20f98348 // cmpq $32, %rcx - LONG $0x082c820f; WORD $0x0000 // jb LBB32_87, $2092(%rip) - WORD $0x8948; BYTE $0xd1 // movq %rdx, %rcx - WORD $0xf748; BYTE $0xd9 // negq %rcx - QUAD $0xfffffe5e056ffdc5 // vmovdqa $-418(%rip), %ymm0 /* LCPI32_0(%rip) */ - QUAD $0xfffffe760d6ffdc5 // vmovdqa $-394(%rip), %ymm1 /* LCPI32_1(%rip) */ - QUAD $0xfffffe8e156ffdc5 // vmovdqa $-370(%rip), %ymm2 /* LCPI32_2(%rip) */ - QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 +LBB28_2: + WORD $0x8b49; BYTE $0x07 // movq (%r15), %rax + LONG $0x084f8b49 // movq $8(%r15), %rcx + WORD $0x2948; BYTE $0xd1 // subq %rdx, %rcx + WORD $0x0148; BYTE $0xc2 // addq %rax, %rdx + LONG $0x20f98348 // cmpq $32, %rcx + LONG $0x0054820f; WORD $0x0000 // jb LBB28_6, $84(%rip) + QUAD $0xfffffe5a056ffdc5 // vmovdqa $-422(%rip), %ymm0 /* LCPI28_0(%rip) */ + QUAD $0xfffffe720d6ffdc5 // vmovdqa $-398(%rip), %ymm1 /* LCPI28_1(%rip) */ + QUAD $0xfffffe8a156ffdc5 // vmovdqa $-374(%rip), %ymm2 /* LCPI28_2(%rip) */ + QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90 -LBB32_4: - LONG $0x1c6ffec5; BYTE $0x10 // vmovdqu (%rax,%rdx), %ymm3 +LBB28_4: + LONG $0x1a6ffec5 // vmovdqu (%rdx), %ymm3 LONG $0xe074e5c5 // vpcmpeqb %ymm0, %ymm3, %ymm4 LONG $0xd9dbe5c5 // vpand %ymm1, %ymm3, %ymm3 LONG $0xda74e5c5 // vpcmpeqb %ymm2, %ymm3, %ymm3 LONG $0xdcebe5c5 // vpor %ymm4, %ymm3, %ymm3 - LONG $0xfbd7fdc5 // vpmovmskb %ymm3, %edi - WORD $0xff85 // testl %edi, %edi - LONG $0x00ca850f; WORD $0x0000 // jne LBB32_18, $202(%rip) + LONG $0xf3d7fdc5 // vpmovmskb %ymm3, %esi + WORD $0xf685 // testl %esi, %esi + LONG $0x00b5850f; WORD $0x0000 // jne LBB28_17, $181(%rip) LONG $0x20c28348 // addq $32, %rdx - LONG $0x0e3c8d48 // leaq (%rsi,%rcx), %rdi - LONG $0xe0c78348 // addq $-32, %rdi LONG $0xe0c18348 // addq $-32, %rcx - LONG $0x1fff8348 // cmpq $31, %rdi - LONG $0xffc5870f; WORD $0xffff // ja LBB32_4, $-59(%rip) - WORD $0x8948; BYTE $0xc2 // movq %rax, %rdx - WORD $0x2948; BYTE $0xca // subq %rcx, %rdx - WORD $0x0148; BYTE $0xce // addq %rcx, %rsi - WORD $0x8948; BYTE $0xf1 // movq %rsi, %rcx - LONG $0x10f98348 // cmpq $16, %rcx - LONG $0x0055820f; WORD $0x0000 // jb LBB32_10, $85(%rip) - -LBB32_7: - WORD $0x8948; BYTE $0xc6 // movq %rax, %rsi - WORD $0x2948; BYTE $0xd6 // subq %rdx, %rsi - QUAD $0xfffffee1056ff9c5 // vmovdqa $-287(%rip), %xmm0 /* LCPI32_3(%rip) */ - QUAD $0xfffffee90d6ff9c5 // vmovdqa $-279(%rip), %xmm1 /* LCPI32_4(%rip) */ - QUAD $0xfffffef1156ff9c5 // vmovdqa $-271(%rip), %xmm2 /* LCPI32_5(%rip) */ - BYTE $0x90 // .p2align 4, 0x90 + LONG $0x1ff98348 // cmpq $31, %rcx + LONG $0xffce870f; WORD $0xffff // ja LBB28_4, $-50(%rip) + +LBB28_6: + LONG $0x10f98348 // cmpq $16, %rcx + LONG $0x0057820f; WORD $0x0000 // jb LBB28_10, $87(%rip) + QUAD $0xfffffefc056ff9c5 // vmovdqa $-260(%rip), %xmm0 /* LCPI28_3(%rip) */ + QUAD $0xffffff040d6ff9c5 // vmovdqa $-252(%rip), %xmm1 /* LCPI28_4(%rip) */ + QUAD $0xffffff0c156ff9c5 // vmovdqa $-244(%rip), %xmm2 /* LCPI28_5(%rip) */ + QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90 -LBB32_8: +LBB28_8: LONG $0x1a6ffac5 // vmovdqu (%rdx), %xmm3 LONG $0xe074e1c5 // vpcmpeqb %xmm0, %xmm3, %xmm4 LONG $0xd9dbe1c5 // vpand %xmm1, %xmm3, %xmm3 LONG $0xda74e1c5 // vpcmpeqb %xmm2, %xmm3, %xmm3 LONG $0xdcebe1c5 // vpor %xmm4, %xmm3, %xmm3 - LONG $0xfbd7f9c5 // vpmovmskb %xmm3, %edi - WORD $0xff85 // testl %edi, %edi - LONG $0x0744850f; WORD $0x0000 // jne LBB32_86, $1860(%rip) + LONG $0xf3d7f9c5 // vpmovmskb %xmm3, %esi + WORD $0x8566; BYTE $0xf6 // testw %si, %si + LONG $0x0751850f; WORD $0x0000 // jne LBB28_86, $1873(%rip) LONG $0x10c28348 // addq $16, %rdx LONG $0xf0c18348 // addq $-16, %rcx - LONG $0xf0c68348 // addq $-16, %rsi LONG $0x0ff98348 // cmpq $15, %rcx - LONG $0xffca870f; WORD $0xffff // ja LBB32_8, $-54(%rip) + LONG $0xffcd870f; WORD $0xffff // ja LBB28_8, $-51(%rip) -LBB32_10: +LBB28_10: WORD $0x8548; BYTE $0xc9 // testq %rcx, %rcx - LONG $0x0034840f; WORD $0x0000 // je LBB32_17, $52(%rip) - LONG $0x0a3c8d48 // leaq (%rdx,%rcx), %rdi - WORD $0xf631 // xorl %esi, %esi - -LBB32_12: - LONG $0x321cb60f // movzbl (%rdx,%rsi), %ebx - WORD $0xfb83; BYTE $0x2c // cmpl $44, %ebx - LONG $0x0750840f; WORD $0x0000 // je LBB32_88, $1872(%rip) - WORD $0xfb83; BYTE $0x7d // cmpl $125, %ebx - LONG $0x0747840f; WORD $0x0000 // je LBB32_88, $1863(%rip) - WORD $0xfb83; BYTE $0x5d // cmpl $93, %ebx - LONG $0x073e840f; WORD $0x0000 // je LBB32_88, $1854(%rip) - WORD $0xff48; BYTE $0xc6 // incq %rsi - WORD $0x3948; BYTE $0xf1 // cmpq %rsi, %rcx - LONG $0xffd5850f; WORD $0xffff // jne LBB32_12, $-43(%rip) - WORD $0x8948; BYTE $0xfa // movq %rdi, %rdx + LONG $0x075b840f; WORD $0x0000 // je LBB28_87, $1883(%rip) + LONG $0x0a348d48 // leaq (%rdx,%rcx), %rsi + +LBB28_12: + WORD $0xb60f; BYTE $0x1a // movzbl (%rdx), %ebx + WORD $0xfb80; BYTE $0x2c // cmpb $44, %bl + LONG $0x074b840f; WORD $0x0000 // je LBB28_87, $1867(%rip) + WORD $0xfb80; BYTE $0x7d // cmpb $125, %bl + LONG $0x0742840f; WORD $0x0000 // je LBB28_87, $1858(%rip) + WORD $0xfb80; BYTE $0x5d // cmpb $93, %bl + LONG $0x0739840f; WORD $0x0000 // je LBB28_87, $1849(%rip) + WORD $0xff48; BYTE $0xc2 // incq %rdx + WORD $0xff48; BYTE $0xc9 // decq %rcx + LONG $0xffd6850f; WORD $0xffff // jne LBB28_12, $-42(%rip) + WORD $0x8948; BYTE $0xf2 // movq %rsi, %rdx + WORD $0x2948; BYTE $0xc2 // subq %rax, %rdx + LONG $0x00000de9; BYTE $0x00 // jmp LBB28_19, $13(%rip) -LBB32_17: - WORD $0x2948; BYTE $0xc2 // subq %rax, %rdx - LONG $0x0003f3e9; BYTE $0x00 // jmp LBB32_59, $1011(%rip) +LBB28_17: + WORD $0x6348; BYTE $0xce // movslq %esi, %rcx -LBB32_18: - WORD $0xbc0f; BYTE $0xc7 // bsfl %edi, %eax - WORD $0x2948; BYTE $0xc8 // subq %rcx, %rax +LBB28_18: + LONG $0xc9bc0f48 // bsfq %rcx, %rcx + WORD $0x2948; BYTE $0xc2 // subq %rax, %rdx + WORD $0x0148; BYTE $0xca // addq %rcx, %rdx -LBB32_19: - WORD $0x8949; BYTE $0x06 // movq %rax, (%r14) +LBB28_19: + WORD $0x8949; BYTE $0x16 // movq %rdx, (%r14) -LBB32_20: +LBB28_20: WORD $0x894c; BYTE $0xe0 // movq %r12, %rax -LBB32_21: +LBB28_21: LONG $0xd8658d48 // leaq $-40(%rbp), %rsp BYTE $0x5b // popq %rbx WORD $0x5c41 // popq %r12 @@ -7975,140 +7497,140 @@ LBB32_21: WORD $0xf8c5; BYTE $0x77 // vzeroupper BYTE $0xc3 // retq -LBB32_22: +LBB28_22: LONG $0x03c28348 // addq $3, %rdx LONG $0x08573b49 // cmpq $8(%r15), %rdx - LONG $0xffe0830f; WORD $0xffff // jae LBB32_21, $-32(%rip) - LONG $0x0003c2e9; BYTE $0x00 // jmp LBB32_59, $962(%rip) + LONG $0xffda860f; WORD $0xffff // jbe LBB28_19, $-38(%rip) + LONG $0xffffdbe9; BYTE $0xff // jmp LBB28_21, $-37(%rip) -LBB32_23: +LBB28_23: WORD $0x894d; BYTE $0x26 // movq %r12, (%r14) LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq $-2, %rax - LONG $0xffffcce9; BYTE $0xff // jmp LBB32_21, $-52(%rip) + LONG $0xffffcce9; BYTE $0xff // jmp LBB28_21, $-52(%rip) -LBB32_24: +LBB28_24: WORD $0x8b49; BYTE $0x0f // movq (%r15), %rcx - LONG $0x08578b4d // movq $8(%r15), %r10 + LONG $0x085f8b4d // movq $8(%r15), %r11 LONG $0x244c8948; BYTE $0x18 // movq %rcx, $24(%rsp) - LONG $0x110c8d4c // leaq (%rcx,%rdx), %r9 - WORD $0x2949; BYTE $0xd2 // subq %rdx, %r10 - LONG $0x20fa8349 // cmpq $32, %r10 - LONG $0x06aa820f; WORD $0x0000 // jb LBB32_33, $1706(%rip) - WORD $0xf631 // xorl %esi, %esi - QUAD $0xfffffd4e056ffdc5 // vmovdqa $-690(%rip), %ymm0 /* LCPI32_6(%rip) */ - QUAD $0xfffffd660d6ffdc5 // vmovdqa $-666(%rip), %ymm1 /* LCPI32_7(%rip) */ - WORD $0xdb31 // xorl %ebx, %ebx - WORD $0x3145; BYTE $0xff // xorl %r15d, %r15d - LONG $0x00006ae9; BYTE $0x00 // jmp LBB32_26, $106(%rip) + LONG $0x113c8d4c // leaq (%rcx,%rdx), %r15 + WORD $0x2949; BYTE $0xd3 // subq %rdx, %r11 + LONG $0x20fb8349 // cmpq $32, %r11 + LONG $0x06b08c0f; WORD $0x0000 // jl LBB28_33, $1712(%rip) + LONG $0x000020bb; BYTE $0x00 // movl $32, %ebx + LONG $0xffffb941; WORD $0xffff // movl $4294967295, %r9d + WORD $0xd231 // xorl %edx, %edx + QUAD $0xfffffd52056ffdc5 // vmovdqa $-686(%rip), %ymm0 /* LCPI28_6(%rip) */ + QUAD $0xfffffd6a0d6ffdc5 // vmovdqa $-662(%rip), %ymm1 /* LCPI28_7(%rip) */ + LONG $0xab918d45; WORD $0xaaaa; BYTE $0xaa // leal $-1431655765(%r9), %r10d + WORD $0xff31 // xorl %edi, %edi + LONG $0x000061e9; BYTE $0x00 // jmp LBB28_26, $97(%rip) QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90 -LBB32_29: - WORD $0x8944; BYTE $0xf9 // movl %r15d, %ecx - WORD $0xd1f7 // notl %ecx - WORD $0xf921 // andl %edi, %ecx - LONG $0x09048d44 // leal (%rcx,%rcx), %r8d - WORD $0x0945; BYTE $0xf8 // orl %r15d, %r8d - WORD $0x8945; BYTE $0xc5 // movl %r8d, %r13d - WORD $0xf741; BYTE $0xd5 // notl %r13d - WORD $0x2141; BYTE $0xfd // andl %edi, %r13d - LONG $0xaae58141; WORD $0xaaaa; BYTE $0xaa // andl $-1431655766, %r13d - WORD $0x3145; BYTE $0xff // xorl %r15d, %r15d - WORD $0x0141; BYTE $0xcd // addl %ecx, %r13d - LONG $0xc7920f41 // setb %r15b - WORD $0x0145; BYTE $0xed // addl %r13d, %r13d - LONG $0x55f58141; WORD $0x5555; BYTE $0x55 // xorl $1431655765, %r13d - WORD $0x2145; BYTE $0xc5 // andl %r8d, %r13d - WORD $0xf741; BYTE $0xd5 // notl %r13d - WORD $0x2145; BYTE $0xeb // andl %r13d, %r11d - WORD $0x854d; BYTE $0xdb // testq %r11, %r11 - LONG $0x004d850f; WORD $0x0000 // jne LBB32_85, $77(%rip) +LBB28_29: + WORD $0xfe89 // movl %edi, %esi + WORD $0x3144; BYTE $0xce // xorl %r9d, %esi + WORD $0xce21 // andl %ecx, %esi + LONG $0x36048d44 // leal (%rsi,%rsi), %r8d + WORD $0x0941; BYTE $0xf8 // orl %edi, %r8d + WORD $0x8944; BYTE $0xc1 // movl %r8d, %ecx + WORD $0x3144; BYTE $0xd1 // xorl %r10d, %ecx + WORD $0xf121 // andl %esi, %ecx + LONG $0xaaaae181; WORD $0xaaaa // andl $-1431655766, %ecx + WORD $0xff31 // xorl %edi, %edi + WORD $0xf101 // addl %esi, %ecx + LONG $0xc7920f40 // setb %dil + WORD $0xc901 // addl %ecx, %ecx + LONG $0x5555f181; WORD $0x5555 // xorl $1431655765, %ecx + WORD $0x2144; BYTE $0xc1 // andl %r8d, %ecx + WORD $0x3144; BYTE $0xc9 // xorl %r9d, %ecx + WORD $0x2141; BYTE $0xcd // andl %ecx, %r13d + WORD $0x8545; BYTE $0xed // testl %r13d, %r13d + LONG $0x0049850f; WORD $0x0000 // jne LBB28_84, $73(%rip) -LBB32_30: - LONG $0x20c38348 // addq $32, %rbx - LONG $0x320c8d49 // leaq (%r10,%rsi), %rcx - LONG $0xe0c18348 // addq $-32, %rcx - LONG $0xe0c68348 // addq $-32, %rsi - LONG $0x1ff98348 // cmpq $31, %rcx - LONG $0x0615860f; WORD $0x0000 // jbe LBB32_31, $1557(%rip) +LBB28_30: + LONG $0x20c28348 // addq $32, %rdx + LONG $0x1b4c8d49; BYTE $0xe0 // leaq $-32(%r11,%rbx), %rcx + LONG $0xe0c38348 // addq $-32, %rbx + LONG $0x3ff98348 // cmpq $63, %rcx + LONG $0x06158e0f; WORD $0x0000 // jle LBB28_31, $1557(%rip) -LBB32_26: - LONG $0x6f7ec1c4; WORD $0x1914 // vmovdqu (%r9,%rbx), %ymm2 +LBB28_26: + LONG $0x6f7ec1c4; WORD $0x1714 // vmovdqu (%r15,%rdx), %ymm2 LONG $0xd874edc5 // vpcmpeqb %ymm0, %ymm2, %ymm3 - LONG $0xdbd77dc5 // vpmovmskb %ymm3, %r11d + LONG $0xebd77dc5 // vpmovmskb %ymm3, %r13d LONG $0xd174edc5 // vpcmpeqb %ymm1, %ymm2, %ymm2 - LONG $0xfad7fdc5 // vpmovmskb %ymm2, %edi - WORD $0xff85 // testl %edi, %edi - LONG $0xff84850f; WORD $0xffff // jne LBB32_29, $-124(%rip) - WORD $0x854d; BYTE $0xff // testq %r15, %r15 - LONG $0xff7b850f; WORD $0xffff // jne LBB32_29, $-133(%rip) - WORD $0x3145; BYTE $0xff // xorl %r15d, %r15d - WORD $0x854d; BYTE $0xdb // testq %r11, %r11 - LONG $0xffb3840f; WORD $0xffff // je LBB32_30, $-77(%rip) + LONG $0xcad7fdc5 // vpmovmskb %ymm2, %ecx + WORD $0x8548; BYTE $0xff // testq %rdi, %rdi + LONG $0xff8c850f; WORD $0xffff // jne LBB28_29, $-116(%rip) + WORD $0xc985 // testl %ecx, %ecx + LONG $0xff84850f; WORD $0xffff // jne LBB28_29, $-124(%rip) + WORD $0xff31 // xorl %edi, %edi + WORD $0x8545; BYTE $0xed // testl %r13d, %r13d + LONG $0xffb7840f; WORD $0xffff // je LBB28_30, $-73(%rip) -LBB32_85: - LONG $0xc3bc0f41 // bsfl %r11d, %eax - WORD $0x0148; BYTE $0xd0 // addq %rdx, %rax - WORD $0x0148; BYTE $0xd8 // addq %rbx, %rax - WORD $0xff48; BYTE $0xc0 // incq %rax - LONG $0xfffedee9; BYTE $0xff // jmp LBB32_19, $-290(%rip) +LBB28_84: + LONG $0xc5bc0f49 // bsfq %r13, %rax + WORD $0x0149; BYTE $0xc7 // addq %rax, %r15 + WORD $0x0149; BYTE $0xd7 // addq %rdx, %r15 + +LBB28_85: + LONG $0x247c2b4c; BYTE $0x18 // subq $24(%rsp), %r15 + WORD $0xff49; BYTE $0xc7 // incq %r15 + WORD $0x894d; BYTE $0x3e // movq %r15, (%r14) + LONG $0xfffed4e9; BYTE $0xff // jmp LBB28_20, $-300(%rip) -LBB32_34: +LBB28_34: LONG $0x084f8b49 // movq $8(%r15), %rcx WORD $0x2948; BYTE $0xd1 // subq %rdx, %rcx WORD $0x0349; BYTE $0x17 // addq (%r15), %rdx WORD $0x3145; BYTE $0xc9 // xorl %r9d, %r9d - QUAD $0xfffffc98056ffdc5 // vmovdqa $-872(%rip), %ymm0 /* LCPI32_7(%rip) */ - QUAD $0xfffffc700d6ffdc5 // vmovdqa $-912(%rip), %ymm1 /* LCPI32_6(%rip) */ + QUAD $0xfffffc9a056ffdc5 // vmovdqa $-870(%rip), %ymm0 /* LCPI28_7(%rip) */ + QUAD $0xfffffc720d6ffdc5 // vmovdqa $-910(%rip), %ymm1 /* LCPI28_6(%rip) */ LONG $0xd276e9c5 // vpcmpeqd %xmm2, %xmm2, %xmm2 - QUAD $0xfffffce41d6ffdc5 // vmovdqa $-796(%rip), %ymm3 /* LCPI32_10(%rip) */ - QUAD $0xfffffc3c256ffdc5 // vmovdqa $-964(%rip), %ymm4 /* LCPI32_2(%rip) */ + QUAD $0xfffffce61d6ffdc5 // vmovdqa $-794(%rip), %ymm3 /* LCPI28_10(%rip) */ + QUAD $0xfffffc3e256ffdc5 // vmovdqa $-962(%rip), %ymm4 /* LCPI28_2(%rip) */ LONG $0x573041c4; BYTE $0xc9 // vxorps %xmm9, %xmm9, %xmm9 WORD $0x3145; BYTE $0xd2 // xorl %r10d, %r10d - WORD $0x3145; BYTE $0xdb // xorl %r11d, %r11d + WORD $0x3145; BYTE $0xc0 // xorl %r8d, %r8d WORD $0xf631 // xorl %esi, %esi - LONG $0x00001ce9; BYTE $0x00 // jmp LBB32_36, $28(%rip) + LONG $0x00001ce9; BYTE $0x00 // jmp LBB28_36, $28(%rip) -LBB32_35: +LBB28_35: LONG $0x3ffdc149 // sarq $63, %r13 - LONG $0xb80f49f3; BYTE $0xc8 // popcntq %r8, %rcx - WORD $0x0149; BYTE $0xcb // addq %rcx, %r11 + LONG $0xb80f49f3; BYTE $0xcb // popcntq %r11, %rcx + WORD $0x0149; BYTE $0xc8 // addq %rcx, %r8 LONG $0x40c28348 // addq $64, %rdx LONG $0x244c8b48; BYTE $0x18 // movq $24(%rsp), %rcx LONG $0xc0c18348 // addq $-64, %rcx WORD $0x894d; BYTE $0xe9 // movq %r13, %r9 -LBB32_36: +LBB28_36: LONG $0x40f98348 // cmpq $64, %rcx LONG $0x244c8948; BYTE $0x18 // movq %rcx, $24(%rsp) - LONG $0x012b8c0f; WORD $0x0000 // jl LBB32_43, $299(%rip) - -LBB32_37: - LONG $0x3a6ffec5 // vmovdqu (%rdx), %ymm7 - LONG $0x726ffec5; BYTE $0x20 // vmovdqu $32(%rdx), %ymm6 - LONG $0xc07445c5 // vpcmpeqb %ymm0, %ymm7, %ymm8 - LONG $0xd77dc1c4; BYTE $0xc8 // vpmovmskb %ymm8, %ecx - LONG $0xc0744dc5 // vpcmpeqb %ymm0, %ymm6, %ymm8 - LONG $0xd77dc1c4; BYTE $0xf8 // vpmovmskb %ymm8, %edi - LONG $0x20e7c148 // shlq $32, %rdi - WORD $0x0948; BYTE $0xf9 // orq %rdi, %rcx - WORD $0x8948; BYTE $0xcf // movq %rcx, %rdi - WORD $0x094c; BYTE $0xd7 // orq %r10, %rdi - LONG $0x000f850f; WORD $0x0000 // jne LBB32_39, $15(%rip) - LONG $0xffc1c748; WORD $0xffff; BYTE $0xff // movq $-1, %rcx - WORD $0x3145; BYTE $0xd2 // xorl %r10d, %r10d - LONG $0x000046e9; BYTE $0x00 // jmp LBB32_40, $70(%rip) - -LBB32_39: + LONG $0x012d8c0f; WORD $0x0000 // jl LBB28_43, $301(%rip) + +LBB28_37: + LONG $0x3a6ffec5 // vmovdqu (%rdx), %ymm7 + LONG $0x726ffec5; BYTE $0x20 // vmovdqu $32(%rdx), %ymm6 + LONG $0xc07445c5 // vpcmpeqb %ymm0, %ymm7, %ymm8 + LONG $0xd77dc1c4; BYTE $0xc8 // vpmovmskb %ymm8, %ecx + LONG $0xc0744dc5 // vpcmpeqb %ymm0, %ymm6, %ymm8 + LONG $0xd77dc1c4; BYTE $0xf8 // vpmovmskb %ymm8, %edi + LONG $0x20e7c148 // shlq $32, %rdi + WORD $0x0948; BYTE $0xf9 // orq %rdi, %rcx + WORD $0x8948; BYTE $0xcf // movq %rcx, %rdi + WORD $0x094c; BYTE $0xd7 // orq %r10, %rdi + LONG $0x004b840f; WORD $0x0000 // je LBB28_39, $75(%rip) WORD $0x894c; BYTE $0xd7 // movq %r10, %rdi WORD $0xf748; BYTE $0xd7 // notq %rdi WORD $0x2148; BYTE $0xcf // andq %rcx, %rdi LONG $0x3f2c8d4c // leaq (%rdi,%rdi), %r13 WORD $0x094d; BYTE $0xd5 // orq %r10, %r13 - WORD $0x894d; BYTE $0xe8 // movq %r13, %r8 - WORD $0xf749; BYTE $0xd0 // notq %r8 + WORD $0x894d; BYTE $0xea // movq %r13, %r10 QUAD $0xaaaaaaaaaaaabb48; WORD $0xaaaa // movabsq $-6148914691236517206, %rbx + WORD $0x3149; BYTE $0xda // xorq %rbx, %r10 WORD $0x2148; BYTE $0xd9 // andq %rbx, %rcx - WORD $0x214c; BYTE $0xc1 // andq %r8, %rcx + WORD $0x214c; BYTE $0xd1 // andq %r10, %rcx WORD $0x3145; BYTE $0xd2 // xorl %r10d, %r10d WORD $0x0148; BYTE $0xf9 // addq %rdi, %rcx LONG $0xc2920f41 // setb %r10b @@ -8117,123 +7639,128 @@ LBB32_39: WORD $0x3148; BYTE $0xf9 // xorq %rdi, %rcx WORD $0x214c; BYTE $0xe9 // andq %r13, %rcx WORD $0xf748; BYTE $0xd1 // notq %rcx + LONG $0x00000ae9; BYTE $0x00 // jmp LBB28_40, $10(%rip) -LBB32_40: - LONG $0xc1744dc5 // vpcmpeqb %ymm1, %ymm6, %ymm8 - LONG $0xd77dc1c4; BYTE $0xf8 // vpmovmskb %ymm8, %edi - LONG $0x20e7c148 // shlq $32, %rdi - LONG $0xc17445c5 // vpcmpeqb %ymm1, %ymm7, %ymm8 - LONG $0xd77dc1c4; BYTE $0xd8 // vpmovmskb %ymm8, %ebx - WORD $0x0948; BYTE $0xfb // orq %rdi, %rbx - WORD $0x2148; BYTE $0xcb // andq %rcx, %rbx - LONG $0x6ef9e1c4; BYTE $0xeb // vmovq %rbx, %xmm5 - LONG $0x4451e3c4; WORD $0x00ea // vpclmulqdq $0, %xmm2, %xmm5, %xmm5 - LONG $0x7ef9c1c4; BYTE $0xed // vmovq %xmm5, %r13 - WORD $0x314d; BYTE $0xcd // xorq %r9, %r13 - LONG $0xeb74c5c5 // vpcmpeqb %ymm3, %ymm7, %ymm5 - LONG $0xc5d77dc5 // vpmovmskb %ymm5, %r8d - LONG $0xeb74cdc5 // vpcmpeqb %ymm3, %ymm6, %ymm5 - LONG $0xfdd7fdc5 // vpmovmskb %ymm5, %edi - LONG $0x20e7c148 // shlq $32, %rdi - WORD $0x0949; BYTE $0xf8 // orq %rdi, %r8 - WORD $0x894d; BYTE $0xe9 // movq %r13, %r9 - WORD $0xf749; BYTE $0xd1 // notq %r9 - WORD $0x214d; BYTE $0xc8 // andq %r9, %r8 - LONG $0xec74c5c5 // vpcmpeqb %ymm4, %ymm7, %ymm5 - LONG $0xddd7fdc5 // vpmovmskb %ymm5, %ebx - LONG $0xec74cdc5 // vpcmpeqb %ymm4, %ymm6, %ymm5 - LONG $0xfdd7fdc5 // vpmovmskb %ymm5, %edi - LONG $0x20e7c148 // shlq $32, %rdi - WORD $0x0948; BYTE $0xfb // orq %rdi, %rbx - WORD $0x214c; BYTE $0xcb // andq %r9, %rbx - LONG $0xfee3840f; WORD $0xffff // je LBB32_35, $-285(%rip) - QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 +LBB28_39: + LONG $0xffc1c748; WORD $0xffff; BYTE $0xff // movq $-1, %rcx + WORD $0x3145; BYTE $0xd2 // xorl %r10d, %r10d -LBB32_41: - LONG $0xff4b8d48 // leaq $-1(%rbx), %rcx - WORD $0x8948; BYTE $0xcf // movq %rcx, %rdi - WORD $0x214c; BYTE $0xc7 // andq %r8, %rdi - LONG $0xb80f48f3; BYTE $0xff // popcntq %rdi, %rdi - WORD $0x014c; BYTE $0xdf // addq %r11, %rdi - WORD $0x3948; BYTE $0xf7 // cmpq %rsi, %rdi - LONG $0x0405860f; WORD $0x0000 // jbe LBB32_84, $1029(%rip) +LBB28_40: + LONG $0xc1744dc5 // vpcmpeqb %ymm1, %ymm6, %ymm8 + LONG $0xd77dc1c4; BYTE $0xf8 // vpmovmskb %ymm8, %edi + LONG $0x20e7c148 // shlq $32, %rdi + LONG $0xc17445c5 // vpcmpeqb %ymm1, %ymm7, %ymm8 + LONG $0xd77dc1c4; BYTE $0xd8 // vpmovmskb %ymm8, %ebx + WORD $0x0948; BYTE $0xfb // orq %rdi, %rbx + WORD $0x2148; BYTE $0xcb // andq %rcx, %rbx + LONG $0x6ef9e1c4; BYTE $0xeb // vmovq %rbx, %xmm5 + LONG $0x4451e3c4; WORD $0x00ea // vpclmulqdq $0, %xmm2, %xmm5, %xmm5 + LONG $0x7ef9c1c4; BYTE $0xed // vmovq %xmm5, %r13 + WORD $0x314d; BYTE $0xcd // xorq %r9, %r13 + LONG $0xeb74c5c5 // vpcmpeqb %ymm3, %ymm7, %ymm5 + LONG $0xddd77dc5 // vpmovmskb %ymm5, %r11d + LONG $0xeb74cdc5 // vpcmpeqb %ymm3, %ymm6, %ymm5 + LONG $0xfdd7fdc5 // vpmovmskb %ymm5, %edi + LONG $0x20e7c148 // shlq $32, %rdi + WORD $0x0949; BYTE $0xfb // orq %rdi, %r11 + WORD $0x894d; BYTE $0xe9 // movq %r13, %r9 + WORD $0xf749; BYTE $0xd1 // notq %r9 + WORD $0x214d; BYTE $0xcb // andq %r9, %r11 + LONG $0xec74c5c5 // vpcmpeqb %ymm4, %ymm7, %ymm5 + LONG $0xfdd7fdc5 // vpmovmskb %ymm5, %edi + LONG $0xec74cdc5 // vpcmpeqb %ymm4, %ymm6, %ymm5 + LONG $0xddd7fdc5 // vpmovmskb %ymm5, %ebx + LONG $0x20e3c148 // shlq $32, %rbx + WORD $0x0948; BYTE $0xdf // orq %rbx, %rdi + WORD $0x214c; BYTE $0xcf // andq %r9, %rdi + LONG $0xfee3840f; WORD $0xffff // je LBB28_35, $-285(%rip) + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB28_41: + LONG $0xff4f8d48 // leaq $-1(%rdi), %rcx + WORD $0x8948; BYTE $0xcb // movq %rcx, %rbx + WORD $0x214c; BYTE $0xdb // andq %r11, %rbx + LONG $0xb80f48f3; BYTE $0xdb // popcntq %rbx, %rbx + WORD $0x014c; BYTE $0xc3 // addq %r8, %rbx + WORD $0x3948; BYTE $0xf3 // cmpq %rsi, %rbx + LONG $0x0404860f; WORD $0x0000 // jbe LBB28_83, $1028(%rip) WORD $0xff48; BYTE $0xc6 // incq %rsi - WORD $0x2148; BYTE $0xcb // andq %rcx, %rbx - LONG $0xffd9850f; WORD $0xffff // jne LBB32_41, $-39(%rip) - LONG $0xfffeaae9; BYTE $0xff // jmp LBB32_35, $-342(%rip) + WORD $0x2148; BYTE $0xcf // andq %rcx, %rdi + LONG $0xffd9850f; WORD $0xffff // jne LBB28_41, $-39(%rip) + LONG $0xfffea8e9; BYTE $0xff // jmp LBB28_35, $-344(%rip) -LBB32_43: +LBB28_43: WORD $0x8548; BYTE $0xc9 // testq %rcx, %rcx - LONG $0x04688e0f; WORD $0x0000 // jle LBB32_89, $1128(%rip) + LONG $0x044a8e0f; WORD $0x0000 // jle LBB28_88, $1098(%rip) LONG $0x4c297cc5; WORD $0x4024 // vmovaps %ymm9, $64(%rsp) LONG $0x4c297cc5; WORD $0x2024 // vmovaps %ymm9, $32(%rsp) WORD $0xd189 // movl %edx, %ecx LONG $0x0fffe181; WORD $0x0000 // andl $4095, %ecx LONG $0x0fc1f981; WORD $0x0000 // cmpl $4033, %ecx - LONG $0xfeac820f; WORD $0xffff // jb LBB32_37, $-340(%rip) + LONG $0xfeaa820f; WORD $0xffff // jb LBB28_37, $-342(%rip) LONG $0x247c8348; WORD $0x2018 // cmpq $32, $24(%rsp) - LONG $0x0021820f; WORD $0x0000 // jb LBB32_47, $33(%rip) + LONG $0x0021820f; WORD $0x0000 // jb LBB28_47, $33(%rip) LONG $0x2a10fcc5 // vmovups (%rdx), %ymm5 LONG $0x6c29fcc5; WORD $0x2024 // vmovaps %ymm5, $32(%rsp) LONG $0x20c28348 // addq $32, %rdx LONG $0x244c8b48; BYTE $0x18 // movq $24(%rsp), %rcx LONG $0xe0598d48 // leaq $-32(%rcx), %rbx LONG $0x247c8d48; BYTE $0x40 // leaq $64(%rsp), %rdi - LONG $0x00000ae9; BYTE $0x00 // jmp LBB32_48, $10(%rip) + LONG $0x00000ae9; BYTE $0x00 // jmp LBB28_48, $10(%rip) -LBB32_47: +LBB28_47: LONG $0x247c8d48; BYTE $0x20 // leaq $32(%rsp), %rdi LONG $0x245c8b48; BYTE $0x18 // movq $24(%rsp), %rbx -LBB32_48: +LBB28_48: LONG $0x10fb8348 // cmpq $16, %rbx - LONG $0x0058820f; WORD $0x0000 // jb LBB32_49, $88(%rip) + LONG $0x0058820f; WORD $0x0000 // jb LBB28_49, $88(%rip) LONG $0x2a10f8c5 // vmovups (%rdx), %xmm5 LONG $0x2f11f8c5 // vmovups %xmm5, (%rdi) LONG $0x10c28348 // addq $16, %rdx LONG $0x10c78348 // addq $16, %rdi LONG $0xf0c38348 // addq $-16, %rbx LONG $0x08fb8348 // cmpq $8, %rbx - LONG $0x0044830f; WORD $0x0000 // jae LBB32_54, $68(%rip) + LONG $0x0044830f; WORD $0x0000 // jae LBB28_54, $68(%rip) -LBB32_50: +LBB28_50: LONG $0x04fb8348 // cmpq $4, %rbx - LONG $0x0056820f; WORD $0x0000 // jb LBB32_51, $86(%rip) + LONG $0x00568c0f; WORD $0x0000 // jl LBB28_51, $86(%rip) -LBB32_55: +LBB28_55: WORD $0x0a8b // movl (%rdx), %ecx WORD $0x0f89 // movl %ecx, (%rdi) LONG $0x04c28348 // addq $4, %rdx LONG $0x04c78348 // addq $4, %rdi LONG $0xfcc38348 // addq $-4, %rbx LONG $0x02fb8348 // cmpq $2, %rbx - LONG $0x0046830f; WORD $0x0000 // jae LBB32_56, $70(%rip) + LONG $0x0046830f; WORD $0x0000 // jae LBB28_56, $70(%rip) -LBB32_52: +LBB28_52: WORD $0x8948; BYTE $0xd1 // movq %rdx, %rcx LONG $0x24548d48; BYTE $0x20 // leaq $32(%rsp), %rdx WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx - LONG $0x0058850f; WORD $0x0000 // jne LBB32_57, $88(%rip) - LONG $0xfffe13e9; BYTE $0xff // jmp LBB32_37, $-493(%rip) + LONG $0x0058850f; WORD $0x0000 // jne LBB28_57, $88(%rip) + LONG $0xfffe11e9; BYTE $0xff // jmp LBB28_37, $-495(%rip) -LBB32_49: +LBB28_49: LONG $0x08fb8348 // cmpq $8, %rbx - LONG $0xffbc820f; WORD $0xffff // jb LBB32_50, $-68(%rip) + LONG $0xffbc820f; WORD $0xffff // jb LBB28_50, $-68(%rip) -LBB32_54: +LBB28_54: WORD $0x8b48; BYTE $0x0a // movq (%rdx), %rcx WORD $0x8948; BYTE $0x0f // movq %rcx, (%rdi) LONG $0x08c28348 // addq $8, %rdx LONG $0x08c78348 // addq $8, %rdi LONG $0xf8c38348 // addq $-8, %rbx LONG $0x04fb8348 // cmpq $4, %rbx - LONG $0xffaa830f; WORD $0xffff // jae LBB32_55, $-86(%rip) + LONG $0xffaa8d0f; WORD $0xffff // jge LBB28_55, $-86(%rip) -LBB32_51: +LBB28_51: LONG $0x02fb8348 // cmpq $2, %rbx - LONG $0xffba820f; WORD $0xffff // jb LBB32_52, $-70(%rip) + LONG $0xffba820f; WORD $0xffff // jb LBB28_52, $-70(%rip) -LBB32_56: +LBB28_56: WORD $0xb70f; BYTE $0x0a // movzwl (%rdx), %ecx WORD $0x8966; BYTE $0x0f // movw %cx, (%rdi) LONG $0x02c28348 // addq $2, %rdx @@ -8242,80 +7769,72 @@ LBB32_56: WORD $0x8948; BYTE $0xd1 // movq %rdx, %rcx LONG $0x24548d48; BYTE $0x20 // leaq $32(%rsp), %rdx WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx - LONG $0xfdc0840f; WORD $0xffff // je LBB32_37, $-576(%rip) + LONG $0xfdbe840f; WORD $0xffff // je LBB28_37, $-578(%rip) -LBB32_57: - WORD $0xb60f; BYTE $0x09 // movzbl (%rcx), %ecx +LBB28_57: + WORD $0x098a // movb (%rcx), %cl WORD $0x0f88 // movb %cl, (%rdi) LONG $0x24548d48; BYTE $0x20 // leaq $32(%rsp), %rdx - LONG $0xfffdb1e9; BYTE $0xff // jmp LBB32_37, $-591(%rip) + LONG $0xfffdb0e9; BYTE $0xff // jmp LBB28_37, $-592(%rip) -LBB32_58: +LBB28_58: LONG $0x04c28348 // addq $4, %rdx LONG $0x08573b49 // cmpq $8(%r15), %rdx - LONG $0xfc19830f; WORD $0xffff // jae LBB32_21, $-999(%rip) + LONG $0xfc05860f; WORD $0xffff // jbe LBB28_19, $-1019(%rip) + LONG $0xfffc06e9; BYTE $0xff // jmp LBB28_21, $-1018(%rip) -LBB32_59: - WORD $0x8949; BYTE $0x16 // movq %rdx, (%r14) - LONG $0xfffc0ee9; BYTE $0xff // jmp LBB32_20, $-1010(%rip) - -LBB32_60: +LBB28_59: LONG $0x084f8b49 // movq $8(%r15), %rcx WORD $0x2948; BYTE $0xd1 // subq %rdx, %rcx WORD $0x0349; BYTE $0x17 // addq (%r15), %rdx WORD $0x3145; BYTE $0xc9 // xorl %r9d, %r9d - QUAD $0xfffff9c5056ffdc5 // vmovdqa $-1595(%rip), %ymm0 /* LCPI32_7(%rip) */ - QUAD $0xfffff99d0d6ffdc5 // vmovdqa $-1635(%rip), %ymm1 /* LCPI32_6(%rip) */ + QUAD $0xfffff9c9056ffdc5 // vmovdqa $-1591(%rip), %ymm0 /* LCPI28_7(%rip) */ + QUAD $0xfffff9a10d6ffdc5 // vmovdqa $-1631(%rip), %ymm1 /* LCPI28_6(%rip) */ LONG $0xd276e9c5 // vpcmpeqd %xmm2, %xmm2, %xmm2 - QUAD $0xfffff9d11d6ffdc5 // vmovdqa $-1583(%rip), %ymm3 /* LCPI32_8(%rip) */ - QUAD $0xfffff9e9256ffdc5 // vmovdqa $-1559(%rip), %ymm4 /* LCPI32_9(%rip) */ + QUAD $0xfffff9d51d6ffdc5 // vmovdqa $-1579(%rip), %ymm3 /* LCPI28_8(%rip) */ + QUAD $0xfffff9ed256ffdc5 // vmovdqa $-1555(%rip), %ymm4 /* LCPI28_9(%rip) */ LONG $0x573041c4; BYTE $0xc9 // vxorps %xmm9, %xmm9, %xmm9 WORD $0x3145; BYTE $0xd2 // xorl %r10d, %r10d - WORD $0x3145; BYTE $0xdb // xorl %r11d, %r11d + WORD $0x3145; BYTE $0xc0 // xorl %r8d, %r8d WORD $0xf631 // xorl %esi, %esi - LONG $0x00001ce9; BYTE $0x00 // jmp LBB32_62, $28(%rip) + LONG $0x00001ce9; BYTE $0x00 // jmp LBB28_61, $28(%rip) -LBB32_61: +LBB28_60: LONG $0x3ffdc149 // sarq $63, %r13 - LONG $0xb80f49f3; BYTE $0xc8 // popcntq %r8, %rcx - WORD $0x0149; BYTE $0xcb // addq %rcx, %r11 + LONG $0xb80f49f3; BYTE $0xcb // popcntq %r11, %rcx + WORD $0x0149; BYTE $0xc8 // addq %rcx, %r8 LONG $0x40c28348 // addq $64, %rdx LONG $0x244c8b48; BYTE $0x18 // movq $24(%rsp), %rcx LONG $0xc0c18348 // addq $-64, %rcx WORD $0x894d; BYTE $0xe9 // movq %r13, %r9 -LBB32_62: +LBB28_61: LONG $0x40f98348 // cmpq $64, %rcx LONG $0x244c8948; BYTE $0x18 // movq %rcx, $24(%rsp) - LONG $0x01288c0f; WORD $0x0000 // jl LBB32_69, $296(%rip) - -LBB32_63: - LONG $0x3a6ffec5 // vmovdqu (%rdx), %ymm7 - LONG $0x726ffec5; BYTE $0x20 // vmovdqu $32(%rdx), %ymm6 - LONG $0xc07445c5 // vpcmpeqb %ymm0, %ymm7, %ymm8 - LONG $0xd77dc1c4; BYTE $0xc8 // vpmovmskb %ymm8, %ecx - LONG $0xc0744dc5 // vpcmpeqb %ymm0, %ymm6, %ymm8 - LONG $0xd77dc1c4; BYTE $0xf8 // vpmovmskb %ymm8, %edi - LONG $0x20e7c148 // shlq $32, %rdi - WORD $0x0948; BYTE $0xf9 // orq %rdi, %rcx - WORD $0x8948; BYTE $0xcf // movq %rcx, %rdi - WORD $0x094c; BYTE $0xd7 // orq %r10, %rdi - LONG $0x000f850f; WORD $0x0000 // jne LBB32_65, $15(%rip) - LONG $0xffc1c748; WORD $0xffff; BYTE $0xff // movq $-1, %rcx - WORD $0x3145; BYTE $0xd2 // xorl %r10d, %r10d - LONG $0x000046e9; BYTE $0x00 // jmp LBB32_66, $70(%rip) - -LBB32_65: + LONG $0x012c8c0f; WORD $0x0000 // jl LBB28_68, $300(%rip) + +LBB28_62: + LONG $0x3a6ffec5 // vmovdqu (%rdx), %ymm7 + LONG $0x726ffec5; BYTE $0x20 // vmovdqu $32(%rdx), %ymm6 + LONG $0xc07445c5 // vpcmpeqb %ymm0, %ymm7, %ymm8 + LONG $0xd77dc1c4; BYTE $0xc8 // vpmovmskb %ymm8, %ecx + LONG $0xc0744dc5 // vpcmpeqb %ymm0, %ymm6, %ymm8 + LONG $0xd77dc1c4; BYTE $0xf8 // vpmovmskb %ymm8, %edi + LONG $0x20e7c148 // shlq $32, %rdi + WORD $0x0948; BYTE $0xf9 // orq %rdi, %rcx + WORD $0x8948; BYTE $0xcf // movq %rcx, %rdi + WORD $0x094c; BYTE $0xd7 // orq %r10, %rdi + LONG $0x004b840f; WORD $0x0000 // je LBB28_64, $75(%rip) WORD $0x894c; BYTE $0xd7 // movq %r10, %rdi WORD $0xf748; BYTE $0xd7 // notq %rdi WORD $0x2148; BYTE $0xcf // andq %rcx, %rdi LONG $0x3f2c8d4c // leaq (%rdi,%rdi), %r13 WORD $0x094d; BYTE $0xd5 // orq %r10, %r13 - WORD $0x894d; BYTE $0xe8 // movq %r13, %r8 - WORD $0xf749; BYTE $0xd0 // notq %r8 + WORD $0x894d; BYTE $0xea // movq %r13, %r10 QUAD $0xaaaaaaaaaaaabb48; WORD $0xaaaa // movabsq $-6148914691236517206, %rbx + WORD $0x3149; BYTE $0xda // xorq %rbx, %r10 WORD $0x2148; BYTE $0xd9 // andq %rbx, %rcx - WORD $0x214c; BYTE $0xc1 // andq %r8, %rcx + WORD $0x214c; BYTE $0xd1 // andq %r10, %rcx WORD $0x3145; BYTE $0xd2 // xorl %r10d, %r10d WORD $0x0148; BYTE $0xf9 // addq %rdi, %rcx LONG $0xc2920f41 // setb %r10b @@ -8324,123 +7843,128 @@ LBB32_65: WORD $0x3148; BYTE $0xf9 // xorq %rdi, %rcx WORD $0x214c; BYTE $0xe9 // andq %r13, %rcx WORD $0xf748; BYTE $0xd1 // notq %rcx + LONG $0x00000ae9; BYTE $0x00 // jmp LBB28_65, $10(%rip) -LBB32_66: - LONG $0xc1744dc5 // vpcmpeqb %ymm1, %ymm6, %ymm8 - LONG $0xd77dc1c4; BYTE $0xf8 // vpmovmskb %ymm8, %edi - LONG $0x20e7c148 // shlq $32, %rdi - LONG $0xc17445c5 // vpcmpeqb %ymm1, %ymm7, %ymm8 - LONG $0xd77dc1c4; BYTE $0xd8 // vpmovmskb %ymm8, %ebx - WORD $0x0948; BYTE $0xfb // orq %rdi, %rbx - WORD $0x2148; BYTE $0xcb // andq %rcx, %rbx - LONG $0x6ef9e1c4; BYTE $0xeb // vmovq %rbx, %xmm5 - LONG $0x4451e3c4; WORD $0x00ea // vpclmulqdq $0, %xmm2, %xmm5, %xmm5 - LONG $0x7ef9c1c4; BYTE $0xed // vmovq %xmm5, %r13 - WORD $0x314d; BYTE $0xcd // xorq %r9, %r13 - LONG $0xeb74c5c5 // vpcmpeqb %ymm3, %ymm7, %ymm5 - LONG $0xc5d77dc5 // vpmovmskb %ymm5, %r8d - LONG $0xeb74cdc5 // vpcmpeqb %ymm3, %ymm6, %ymm5 - LONG $0xfdd7fdc5 // vpmovmskb %ymm5, %edi - LONG $0x20e7c148 // shlq $32, %rdi - WORD $0x0949; BYTE $0xf8 // orq %rdi, %r8 - WORD $0x894d; BYTE $0xe9 // movq %r13, %r9 - WORD $0xf749; BYTE $0xd1 // notq %r9 - WORD $0x214d; BYTE $0xc8 // andq %r9, %r8 - LONG $0xec74c5c5 // vpcmpeqb %ymm4, %ymm7, %ymm5 - LONG $0xddd7fdc5 // vpmovmskb %ymm5, %ebx - LONG $0xec74cdc5 // vpcmpeqb %ymm4, %ymm6, %ymm5 - LONG $0xfdd7fdc5 // vpmovmskb %ymm5, %edi - LONG $0x20e7c148 // shlq $32, %rdi - WORD $0x0948; BYTE $0xfb // orq %rdi, %rbx - WORD $0x214c; BYTE $0xcb // andq %r9, %rbx - LONG $0xfee3840f; WORD $0xffff // je LBB32_61, $-285(%rip) - QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90 +LBB28_64: + LONG $0xffc1c748; WORD $0xffff; BYTE $0xff // movq $-1, %rcx + WORD $0x3145; BYTE $0xd2 // xorl %r10d, %r10d -LBB32_67: - LONG $0xff4b8d48 // leaq $-1(%rbx), %rcx - WORD $0x8948; BYTE $0xcf // movq %rcx, %rdi - WORD $0x214c; BYTE $0xc7 // andq %r8, %rdi - LONG $0xb80f48f3; BYTE $0xff // popcntq %rdi, %rdi - WORD $0x014c; BYTE $0xdf // addq %r11, %rdi - WORD $0x3948; BYTE $0xf7 // cmpq %rsi, %rdi - LONG $0x0135860f; WORD $0x0000 // jbe LBB32_84, $309(%rip) +LBB28_65: + LONG $0xc1744dc5 // vpcmpeqb %ymm1, %ymm6, %ymm8 + LONG $0xd77dc1c4; BYTE $0xf8 // vpmovmskb %ymm8, %edi + LONG $0x20e7c148 // shlq $32, %rdi + LONG $0xc17445c5 // vpcmpeqb %ymm1, %ymm7, %ymm8 + LONG $0xd77dc1c4; BYTE $0xd8 // vpmovmskb %ymm8, %ebx + WORD $0x0948; BYTE $0xfb // orq %rdi, %rbx + WORD $0x2148; BYTE $0xcb // andq %rcx, %rbx + LONG $0x6ef9e1c4; BYTE $0xeb // vmovq %rbx, %xmm5 + LONG $0x4451e3c4; WORD $0x00ea // vpclmulqdq $0, %xmm2, %xmm5, %xmm5 + LONG $0x7ef9c1c4; BYTE $0xed // vmovq %xmm5, %r13 + WORD $0x314d; BYTE $0xcd // xorq %r9, %r13 + LONG $0xeb74c5c5 // vpcmpeqb %ymm3, %ymm7, %ymm5 + LONG $0xddd77dc5 // vpmovmskb %ymm5, %r11d + LONG $0xeb74cdc5 // vpcmpeqb %ymm3, %ymm6, %ymm5 + LONG $0xfdd7fdc5 // vpmovmskb %ymm5, %edi + LONG $0x20e7c148 // shlq $32, %rdi + WORD $0x0949; BYTE $0xfb // orq %rdi, %r11 + WORD $0x894d; BYTE $0xe9 // movq %r13, %r9 + WORD $0xf749; BYTE $0xd1 // notq %r9 + WORD $0x214d; BYTE $0xcb // andq %r9, %r11 + LONG $0xec74c5c5 // vpcmpeqb %ymm4, %ymm7, %ymm5 + LONG $0xfdd7fdc5 // vpmovmskb %ymm5, %edi + LONG $0xec74cdc5 // vpcmpeqb %ymm4, %ymm6, %ymm5 + LONG $0xddd7fdc5 // vpmovmskb %ymm5, %ebx + LONG $0x20e3c148 // shlq $32, %rbx + WORD $0x0948; BYTE $0xdf // orq %rbx, %rdi + WORD $0x214c; BYTE $0xcf // andq %r9, %rdi + LONG $0xfee3840f; WORD $0xffff // je LBB28_60, $-285(%rip) + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 + +LBB28_66: + LONG $0xff4f8d48 // leaq $-1(%rdi), %rcx + WORD $0x8948; BYTE $0xcb // movq %rcx, %rbx + WORD $0x214c; BYTE $0xdb // andq %r11, %rbx + LONG $0xb80f48f3; BYTE $0xdb // popcntq %rbx, %rbx + WORD $0x014c; BYTE $0xc3 // addq %r8, %rbx + WORD $0x3948; BYTE $0xf3 // cmpq %rsi, %rbx + LONG $0x0134860f; WORD $0x0000 // jbe LBB28_83, $308(%rip) WORD $0xff48; BYTE $0xc6 // incq %rsi - WORD $0x2148; BYTE $0xcb // andq %rcx, %rbx - LONG $0xffd9850f; WORD $0xffff // jne LBB32_67, $-39(%rip) - LONG $0xfffeade9; BYTE $0xff // jmp LBB32_61, $-339(%rip) + WORD $0x2148; BYTE $0xcf // andq %rcx, %rdi + LONG $0xffd9850f; WORD $0xffff // jne LBB28_66, $-39(%rip) + LONG $0xfffea9e9; BYTE $0xff // jmp LBB28_60, $-343(%rip) -LBB32_69: +LBB28_68: WORD $0x8548; BYTE $0xc9 // testq %rcx, %rcx - LONG $0x01988e0f; WORD $0x0000 // jle LBB32_89, $408(%rip) + LONG $0x017a8e0f; WORD $0x0000 // jle LBB28_88, $378(%rip) LONG $0x4c297cc5; WORD $0x4024 // vmovaps %ymm9, $64(%rsp) LONG $0x4c297cc5; WORD $0x2024 // vmovaps %ymm9, $32(%rsp) WORD $0xd189 // movl %edx, %ecx LONG $0x0fffe181; WORD $0x0000 // andl $4095, %ecx LONG $0x0fc1f981; WORD $0x0000 // cmpl $4033, %ecx - LONG $0xfeaf820f; WORD $0xffff // jb LBB32_63, $-337(%rip) + LONG $0xfeab820f; WORD $0xffff // jb LBB28_62, $-341(%rip) LONG $0x247c8348; WORD $0x2018 // cmpq $32, $24(%rsp) - LONG $0x0021820f; WORD $0x0000 // jb LBB32_73, $33(%rip) + LONG $0x0021820f; WORD $0x0000 // jb LBB28_72, $33(%rip) LONG $0x2a10fcc5 // vmovups (%rdx), %ymm5 LONG $0x6c29fcc5; WORD $0x2024 // vmovaps %ymm5, $32(%rsp) LONG $0x20c28348 // addq $32, %rdx LONG $0x244c8b48; BYTE $0x18 // movq $24(%rsp), %rcx LONG $0xe0598d48 // leaq $-32(%rcx), %rbx LONG $0x247c8d48; BYTE $0x40 // leaq $64(%rsp), %rdi - LONG $0x00000ae9; BYTE $0x00 // jmp LBB32_74, $10(%rip) + LONG $0x00000ae9; BYTE $0x00 // jmp LBB28_73, $10(%rip) -LBB32_73: +LBB28_72: LONG $0x247c8d48; BYTE $0x20 // leaq $32(%rsp), %rdi LONG $0x245c8b48; BYTE $0x18 // movq $24(%rsp), %rbx -LBB32_74: +LBB28_73: LONG $0x10fb8348 // cmpq $16, %rbx - LONG $0x0058820f; WORD $0x0000 // jb LBB32_75, $88(%rip) + LONG $0x0058820f; WORD $0x0000 // jb LBB28_74, $88(%rip) LONG $0x2a10f8c5 // vmovups (%rdx), %xmm5 LONG $0x2f11f8c5 // vmovups %xmm5, (%rdi) LONG $0x10c28348 // addq $16, %rdx LONG $0x10c78348 // addq $16, %rdi LONG $0xf0c38348 // addq $-16, %rbx LONG $0x08fb8348 // cmpq $8, %rbx - LONG $0x0044830f; WORD $0x0000 // jae LBB32_80, $68(%rip) + LONG $0x0044830f; WORD $0x0000 // jae LBB28_79, $68(%rip) -LBB32_76: +LBB28_75: LONG $0x04fb8348 // cmpq $4, %rbx - LONG $0x0056820f; WORD $0x0000 // jb LBB32_77, $86(%rip) + LONG $0x00568c0f; WORD $0x0000 // jl LBB28_76, $86(%rip) -LBB32_81: +LBB28_80: WORD $0x0a8b // movl (%rdx), %ecx WORD $0x0f89 // movl %ecx, (%rdi) LONG $0x04c28348 // addq $4, %rdx LONG $0x04c78348 // addq $4, %rdi LONG $0xfcc38348 // addq $-4, %rbx LONG $0x02fb8348 // cmpq $2, %rbx - LONG $0x0046830f; WORD $0x0000 // jae LBB32_82, $70(%rip) + LONG $0x0046830f; WORD $0x0000 // jae LBB28_81, $70(%rip) -LBB32_78: +LBB28_77: WORD $0x8948; BYTE $0xd1 // movq %rdx, %rcx LONG $0x24548d48; BYTE $0x20 // leaq $32(%rsp), %rdx WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx - LONG $0x0058850f; WORD $0x0000 // jne LBB32_83, $88(%rip) - LONG $0xfffe16e9; BYTE $0xff // jmp LBB32_63, $-490(%rip) + LONG $0x0058850f; WORD $0x0000 // jne LBB28_82, $88(%rip) + LONG $0xfffe12e9; BYTE $0xff // jmp LBB28_62, $-494(%rip) -LBB32_75: +LBB28_74: LONG $0x08fb8348 // cmpq $8, %rbx - LONG $0xffbc820f; WORD $0xffff // jb LBB32_76, $-68(%rip) + LONG $0xffbc820f; WORD $0xffff // jb LBB28_75, $-68(%rip) -LBB32_80: +LBB28_79: WORD $0x8b48; BYTE $0x0a // movq (%rdx), %rcx WORD $0x8948; BYTE $0x0f // movq %rcx, (%rdi) LONG $0x08c28348 // addq $8, %rdx LONG $0x08c78348 // addq $8, %rdi LONG $0xf8c38348 // addq $-8, %rbx LONG $0x04fb8348 // cmpq $4, %rbx - LONG $0xffaa830f; WORD $0xffff // jae LBB32_81, $-86(%rip) + LONG $0xffaa8d0f; WORD $0xffff // jge LBB28_80, $-86(%rip) -LBB32_77: +LBB28_76: LONG $0x02fb8348 // cmpq $2, %rbx - LONG $0xffba820f; WORD $0xffff // jb LBB32_78, $-70(%rip) + LONG $0xffba820f; WORD $0xffff // jb LBB28_77, $-70(%rip) -LBB32_82: +LBB28_81: WORD $0xb70f; BYTE $0x0a // movzwl (%rdx), %ecx WORD $0x8966; BYTE $0x0f // movw %cx, (%rdi) LONG $0x02c28348 // addq $2, %rdx @@ -8449,237 +7973,227 @@ LBB32_82: WORD $0x8948; BYTE $0xd1 // movq %rdx, %rcx LONG $0x24548d48; BYTE $0x20 // leaq $32(%rsp), %rdx WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx - LONG $0xfdc3840f; WORD $0xffff // je LBB32_63, $-573(%rip) + LONG $0xfdbf840f; WORD $0xffff // je LBB28_62, $-577(%rip) -LBB32_83: - WORD $0xb60f; BYTE $0x09 // movzbl (%rcx), %ecx +LBB28_82: + WORD $0x098a // movb (%rcx), %cl WORD $0x0f88 // movb %cl, (%rdi) LONG $0x24548d48; BYTE $0x20 // leaq $32(%rsp), %rdx - LONG $0xfffdb4e9; BYTE $0xff // jmp LBB32_63, $-588(%rip) + LONG $0xfffdb1e9; BYTE $0xff // jmp LBB28_62, $-591(%rip) -LBB32_84: +LBB28_83: LONG $0x08478b49 // movq $8(%r15), %rax - LONG $0xcbbc0f48 // bsfq %rbx, %rcx + LONG $0xcfbc0f48 // bsfq %rdi, %rcx LONG $0x244c2b48; BYTE $0x18 // subq $24(%rsp), %rcx - WORD $0x0148; BYTE $0xc8 // addq %rcx, %rax - WORD $0xff48; BYTE $0xc0 // incq %rax + LONG $0x01448d48; BYTE $0x01 // leaq $1(%rcx,%rax), %rax WORD $0x8949; BYTE $0x06 // movq %rax, (%r14) LONG $0x084f8b49 // movq $8(%r15), %rcx WORD $0x3948; BYTE $0xc8 // cmpq %rcx, %rax - LONG $0xc8420f48 // cmovbq %rax, %rcx - WORD $0x8949; BYTE $0x0e // movq %rcx, (%r14) + LONG $0xc1470f48 // cmovaq %rcx, %rax + WORD $0x8949; BYTE $0x06 // movq %rax, (%r14) LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax LONG $0xe0470f4c // cmovaq %rax, %r12 - LONG $0xfff920e9; BYTE $0xff // jmp LBB32_20, $-1760(%rip) + LONG $0xfff913e9; BYTE $0xff // jmp LBB28_20, $-1773(%rip) -LBB32_86: - LONG $0xc7bc0f66 // bsfw %di, %ax - WORD $0xb70f; BYTE $0xc0 // movzwl %ax, %eax - WORD $0x2948; BYTE $0xf0 // subq %rsi, %rax - LONG $0xfff90ee9; BYTE $0xff // jmp LBB32_19, $-1778(%rip) - -LBB32_31: - WORD $0x854d; BYTE $0xff // testq %r15, %r15 - LONG $0x003d850f; WORD $0x0000 // jne LBB32_90, $61(%rip) - WORD $0x0149; BYTE $0xd9 // addq %rbx, %r9 - WORD $0x0149; BYTE $0xf2 // addq %rsi, %r10 +LBB28_86: + WORD $0xb70f; BYTE $0xce // movzwl %si, %ecx + LONG $0xfff8fee9; BYTE $0xff // jmp LBB28_18, $-1794(%rip) -LBB32_33: - WORD $0x854d; BYTE $0xd2 // testq %r10, %r10 - LONG $0x0070850f; WORD $0x0000 // jne LBB32_94, $112(%rip) - LONG $0xfff8f7e9; BYTE $0xff // jmp LBB32_21, $-1801(%rip) +LBB28_31: + WORD $0x8548; BYTE $0xff // testq %rdi, %rdi + LONG $0x0028850f; WORD $0x0000 // jne LBB28_89, $40(%rip) + WORD $0x0149; BYTE $0xd7 // addq %rdx, %r15 + WORD $0x2949; BYTE $0xd3 // subq %rdx, %r11 -LBB32_87: - WORD $0x0148; BYTE $0xc2 // addq %rax, %rdx - LONG $0x10f98348 // cmpq $16, %rcx - LONG $0xf844830f; WORD $0xffff // jae LBB32_7, $-1980(%rip) - LONG $0xfff894e9; BYTE $0xff // jmp LBB32_10, $-1900(%rip) +LBB28_33: + WORD $0x854d; BYTE $0xdb // testq %r11, %r11 + LONG $0x005a8f0f; WORD $0x0000 // jg LBB28_93, $90(%rip) + LONG $0xfff8f1e9; BYTE $0xff // jmp LBB28_21, $-1807(%rip) -LBB32_88: +LBB28_87: WORD $0x2948; BYTE $0xc2 // subq %rax, %rdx - WORD $0x0148; BYTE $0xf2 // addq %rsi, %rdx - LONG $0xfffcc1e9; BYTE $0xff // jmp LBB32_59, $-831(%rip) + LONG $0xfff8e3e9; BYTE $0xff // jmp LBB28_19, $-1821(%rip) -LBB32_89: +LBB28_88: LONG $0x084f8b49 // movq $8(%r15), %rcx WORD $0x8949; BYTE $0x0e // movq %rcx, (%r14) - LONG $0xfff8cee9; BYTE $0xff // jmp LBB32_21, $-1842(%rip) + LONG $0xfff8dde9; BYTE $0xff // jmp LBB28_21, $-1827(%rip) -LBB32_90: - WORD $0x3949; BYTE $0xda // cmpq %rbx, %r10 - LONG $0xf8c5840f; WORD $0xffff // je LBB32_21, $-1851(%rip) - WORD $0x0149; BYTE $0xd9 // addq %rbx, %r9 - WORD $0xff49; BYTE $0xc1 // incq %r9 - WORD $0xf748; BYTE $0xd3 // notq %rbx - WORD $0x0149; BYTE $0xda // addq %rbx, %r10 - WORD $0x854d; BYTE $0xd2 // testq %r10, %r10 - LONG $0x0024850f; WORD $0x0000 // jne LBB32_94, $36(%rip) - LONG $0xfff8abe9; BYTE $0xff // jmp LBB32_21, $-1877(%rip) +LBB28_89: + WORD $0x3949; BYTE $0xd3 // cmpq %rdx, %r11 + LONG $0xf8d4840f; WORD $0xffff // je LBB28_21, $-1836(%rip) + LONG $0x177c8d4d; BYTE $0x01 // leaq $1(%r15,%rdx), %r15 + WORD $0xf748; BYTE $0xd2 // notq %rdx + WORD $0x0149; BYTE $0xd3 // addq %rdx, %r11 + WORD $0x854d; BYTE $0xdb // testq %r11, %r11 + LONG $0x00248f0f; WORD $0x0000 // jg LBB28_93, $36(%rip) + LONG $0xfff8bbe9; BYTE $0xff // jmp LBB28_21, $-1861(%rip) -LBB32_92: - LONG $0xfec1c748; WORD $0xffff; BYTE $0xff // movq $-2, %rcx +LBB28_91: + LONG $0xfec2c748; WORD $0xffff; BYTE $0xff // movq $-2, %rdx LONG $0x000002b8; BYTE $0x00 // movl $2, %eax - WORD $0x0149; BYTE $0xc1 // addq %rax, %r9 + WORD $0x0149; BYTE $0xc7 // addq %rax, %r15 LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax - WORD $0x0149; BYTE $0xca // addq %rcx, %r10 - LONG $0xf88c840f; WORD $0xffff // je LBB32_21, $-1908(%rip) - -LBB32_94: - LONG $0x01b60f41 // movzbl (%r9), %eax - WORD $0xf883; BYTE $0x5c // cmpl $92, %eax - LONG $0xffd4840f; WORD $0xffff // je LBB32_92, $-44(%rip) - WORD $0xf883; BYTE $0x22 // cmpl $34, %eax - LONG $0x0024840f; WORD $0x0000 // je LBB32_97, $36(%rip) - LONG $0xffc1c748; WORD $0xffff; BYTE $0xff // movq $-1, %rcx + WORD $0x0149; BYTE $0xd3 // addq %rdx, %r11 + LONG $0xf89c8e0f; WORD $0xffff // jle LBB28_21, $-1892(%rip) + +LBB28_93: + LONG $0x07b60f41 // movzbl (%r15), %eax + WORD $0x5c3c // cmpb $92, %al + LONG $0xffd5840f; WORD $0xffff // je LBB28_91, $-43(%rip) + WORD $0x223c // cmpb $34, %al + LONG $0xf9a1840f; WORD $0xffff // je LBB28_85, $-1631(%rip) + LONG $0xffc2c748; WORD $0xffff; BYTE $0xff // movq $-1, %rdx LONG $0x000001b8; BYTE $0x00 // movl $1, %eax - WORD $0x0149; BYTE $0xc1 // addq %rax, %r9 + WORD $0x0149; BYTE $0xc7 // addq %rax, %r15 LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax - WORD $0x0149; BYTE $0xca // addq %rcx, %r10 - LONG $0xffcb850f; WORD $0xffff // jne LBB32_94, $-53(%rip) - LONG $0xfff852e9; BYTE $0xff // jmp LBB32_21, $-1966(%rip) + WORD $0x0149; BYTE $0xd3 // addq %rdx, %r11 + LONG $0xffcd8f0f; WORD $0xffff // jg LBB28_93, $-51(%rip) + LONG $0xfff864e9; BYTE $0xff // jmp LBB28_21, $-1948(%rip) -LBB32_97: - LONG $0x244c2b4c; BYTE $0x18 // subq $24(%rsp), %r9 - WORD $0xff49; BYTE $0xc1 // incq %r9 - WORD $0x894d; BYTE $0x0e // movq %r9, (%r14) - LONG $0xfff83fe9; BYTE $0xff // jmp LBB32_20, $-1985(%rip) - WORD $0x9090; BYTE $0x90 // .p2align 2, 0x90 - - // .set L32_0_set_21, LBB32_21-LJTI32_0 - // .set L32_0_set_23, LBB32_23-LJTI32_0 - // .set L32_0_set_24, LBB32_24-LJTI32_0 - // .set L32_0_set_2, LBB32_2-LJTI32_0 - // .set L32_0_set_34, LBB32_34-LJTI32_0 - // .set L32_0_set_58, LBB32_58-LJTI32_0 - // .set L32_0_set_22, LBB32_22-LJTI32_0 - // .set L32_0_set_60, LBB32_60-LJTI32_0 -LJTI32_0: - LONG $0xfffff83f // .long L32_0_set_21 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff873 // .long L32_0_set_24 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff705 // .long L32_0_set_2 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff705 // .long L32_0_set_2 - LONG $0xfffff705 // .long L32_0_set_2 - LONG $0xfffff705 // .long L32_0_set_2 - LONG $0xfffff705 // .long L32_0_set_2 - LONG $0xfffff705 // .long L32_0_set_2 - LONG $0xfffff705 // .long L32_0_set_2 - LONG $0xfffff705 // .long L32_0_set_2 - LONG $0xfffff705 // .long L32_0_set_2 - LONG $0xfffff705 // .long L32_0_set_2 - LONG $0xfffff705 // .long L32_0_set_2 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff95b // .long L32_0_set_34 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffffc18 // .long L32_0_set_58 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff851 // .long L32_0_set_22 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff851 // .long L32_0_set_22 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffff864 // .long L32_0_set_23 - LONG $0xfffffc2e // .long L32_0_set_60 - QUAD $0x9090909090909090 // .p2align 4, 0x90 + // .p2align 2, 0x90 + // .set L28_0_set_21, LBB28_21-LJTI28_0 + // .set L28_0_set_23, LBB28_23-LJTI28_0 + // .set L28_0_set_24, LBB28_24-LJTI28_0 + // .set L28_0_set_2, LBB28_2-LJTI28_0 + // .set L28_0_set_34, LBB28_34-LJTI28_0 + // .set L28_0_set_58, LBB28_58-LJTI28_0 + // .set L28_0_set_22, LBB28_22-LJTI28_0 + // .set L28_0_set_59, LBB28_59-LJTI28_0 +LJTI28_0: + LONG $0xfffff864 // .long L28_0_set_21 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff898 // .long L28_0_set_24 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff743 // .long L28_0_set_2 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff743 // .long L28_0_set_2 + LONG $0xfffff743 // .long L28_0_set_2 + LONG $0xfffff743 // .long L28_0_set_2 + LONG $0xfffff743 // .long L28_0_set_2 + LONG $0xfffff743 // .long L28_0_set_2 + LONG $0xfffff743 // .long L28_0_set_2 + LONG $0xfffff743 // .long L28_0_set_2 + LONG $0xfffff743 // .long L28_0_set_2 + LONG $0xfffff743 // .long L28_0_set_2 + LONG $0xfffff743 // .long L28_0_set_2 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff98d // .long L28_0_set_34 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffffc4b // .long L28_0_set_58 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff876 // .long L28_0_set_22 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff876 // .long L28_0_set_22 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffff889 // .long L28_0_set_23 + LONG $0xfffffc5e // .long L28_0_set_59 + QUAD $0x0000000000000000; LONG $0x00000000 // .p2align 4, 0x00 +LCPI29_0: + LONG $0x00000001 // .long 1 + LONG $0x00000000 // .long 0 + LONG $0x00000000 // .long 0 + LONG $0x00000000 // .long 0 + + // .p2align 4, 0x90 _get_by_path: BYTE $0x55 // pushq %rbp WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp @@ -8688,326 +8202,533 @@ _get_by_path: WORD $0x5541 // pushq %r13 WORD $0x5441 // pushq %r12 BYTE $0x53 // pushq %rbx - LONG $0x38ec8348 // subq $56, %rsp - WORD $0x8949; BYTE $0xf6 // movq %rsi, %r14 - WORD $0x8949; BYTE $0xff // movq %rdi, %r15 + LONG $0x28ec8348 // subq $40, %rsp + WORD $0x8949; BYTE $0xf7 // movq %rsi, %r15 + WORD $0x8949; BYTE $0xfd // movq %rdi, %r13 LONG $0x08428b48 // movq $8(%rdx), %rax WORD $0x8548; BYTE $0xc0 // testq %rax, %rax - LONG $0x041d840f; WORD $0x0000 // je LBB33_67, $1053(%rip) - WORD $0x8b4c; BYTE $0x22 // movq (%rdx), %r12 + LONG $0x06d1840f; WORD $0x0000 // je LBB29_93, $1745(%rip) + WORD $0x8b4c; BYTE $0x32 // movq (%rdx), %r14 LONG $0x04e0c148 // shlq $4, %rax - WORD $0x014c; BYTE $0xe0 // addq %r12, %rax - LONG $0xa0458948 // movq %rax, $-96(%rbp) - -LBB33_2: - WORD $0x894c; BYTE $0xff // movq %r15, %rdi - WORD $0x894c; BYTE $0xf6 // movq %r14, %rsi - LONG $0xffd173e8; BYTE $0xff // callq _advance_ns, $-11917(%rip) - LONG $0x240c8b49 // movq (%r12), %rcx - LONG $0x1749b60f // movzbl $23(%rcx), %ecx - WORD $0xe180; BYTE $0x1f // andb $31, %cl - WORD $0xf980; BYTE $0x18 // cmpb $24, %cl - LONG $0x038f850f; WORD $0x0000 // jne LBB33_61, $911(%rip) - WORD $0x7b3c // cmpb $123, %al - LONG $0xd07d894c // movq %r15, $-48(%rbp) - LONG $0xb865894c // movq %r12, $-72(%rbp) - LONG $0x03f0850f; WORD $0x0000 // jne LBB33_68, $1008(%rip) - QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + WORD $0x014c; BYTE $0xf0 // addq %r14, %rax + LONG $0xb04d8948 // movq %rcx, $-80(%rbp) + LONG $0xb8458948 // movq %rax, $-72(%rbp) + +LBB29_2: + LONG $0x007d8b49 // movq (%r13), %rdi + LONG $0x08758b49 // movq $8(%r13), %rsi + WORD $0x894c; BYTE $0xfa // movq %r15, %rdx + LONG $0xffd1cae8; BYTE $0xff // callq _advance_ns, $-11830(%rip) + WORD $0x8b49; BYTE $0x0e // movq (%r14), %rcx + WORD $0x8548; BYTE $0xc9 // testq %rcx, %rcx + LONG $0x06fc840f; WORD $0x0000 // je LBB29_99, $1788(%rip) + WORD $0x498a; BYTE $0x17 // movb $23(%rcx), %cl + WORD $0xe180; BYTE $0x1f // andb $31, %cl + WORD $0xf980; BYTE $0x02 // cmpb $2, %cl + LONG $0x05ff840f; WORD $0x0000 // je LBB29_86, $1535(%rip) + WORD $0xf980; BYTE $0x18 // cmpb $24, %cl + LONG $0x06e4850f; WORD $0x0000 // jne LBB29_99, $1764(%rip) + WORD $0x7b3c // cmpb $123, %al + LONG $0xc875894c // movq %r14, $-56(%rbp) + LONG $0x06bf850f; WORD $0x0000 // jne LBB29_97, $1727(%rip) + QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90 -LBB33_4: - WORD $0x894c; BYTE $0xff // movq %r15, %rdi - WORD $0x894c; BYTE $0xf6 // movq %r14, %rsi - LONG $0xffd135e8; BYTE $0xff // callq _advance_ns, $-11979(%rip) +LBB29_6: + LONG $0x007d8b49 // movq (%r13), %rdi + LONG $0x08758b49 // movq $8(%r13), %rsi + WORD $0x894c; BYTE $0xfa // movq %r15, %rdx + LONG $0xffd180e8; BYTE $0xff // callq _advance_ns, $-11904(%rip) WORD $0x223c // cmpb $34, %al - LONG $0x03ce850f; WORD $0x0000 // jne LBB33_68, $974(%rip) - LONG $0x24448b49; BYTE $0x08 // movq $8(%r12), %rax - WORD $0x8b4c; BYTE $0x28 // movq (%rax), %r13 - WORD $0x894c; BYTE $0xff // movq %r15, %rdi - LONG $0x08788b4c // movq $8(%rax), %r15 - QUAD $0xffffffffb045c748 // movq $-1, $-80(%rbp) - WORD $0x8b4d; BYTE $0x26 // movq (%r14), %r12 - WORD $0x894c; BYTE $0xe6 // movq %r12, %rsi - LONG $0xb0558d48 // leaq $-80(%rbp), %rdx - LONG $0x002647e8; BYTE $0x00 // callq _advance_string_default, $9799(%rip) + LONG $0x067e850f; WORD $0x0000 // jne LBB29_94, $1662(%rip) + LONG $0x08468b49 // movq $8(%r14), %rax + WORD $0x8b4c; BYTE $0x30 // movq (%rax), %r14 + LONG $0x08608b4c // movq $8(%rax), %r12 + QUAD $0xffffffffc045c748 // movq $-1, $-64(%rbp) + WORD $0x8b49; BYTE $0x1f // movq (%r15), %rbx + WORD $0x894c; BYTE $0xef // movq %r13, %rdi + WORD $0x8948; BYTE $0xde // movq %rbx, %rsi + LONG $0xc0558d48 // leaq $-64(%rbp), %rdx + LONG $0x0027f3e8; BYTE $0x00 // callq _advance_string_default, $10227(%rip) WORD $0x8548; BYTE $0xc0 // testq %rax, %rax - LONG $0x03b8880f; WORD $0x0000 // js LBB33_70, $952(%rip) - WORD $0x8949; BYTE $0x06 // movq %rax, (%r14) - LONG $0xb04d8b48 // movq $-80(%rbp), %rcx + LONG $0x0697880f; WORD $0x0000 // js LBB29_100, $1687(%rip) + WORD $0x8949; BYTE $0x07 // movq %rax, (%r15) + LONG $0xc04d8b48 // movq $-64(%rbp), %rcx LONG $0xfff98348 // cmpq $-1, %rcx - LONG $0x0009840f; WORD $0x0000 // je LBB33_8, $9(%rip) + LONG $0x0009840f; WORD $0x0000 // je LBB29_10, $9(%rip) WORD $0x3948; BYTE $0xc1 // cmpq %rax, %rcx - LONG $0x02018e0f; WORD $0x0000 // jle LBB33_37, $513(%rip) + LONG $0x01d48e0f; WORD $0x0000 // jle LBB29_40, $468(%rip) -LBB33_8: - WORD $0x894c; BYTE $0xe1 // movq %r12, %rcx - WORD $0xf748; BYTE $0xd1 // notq %rcx - WORD $0x0148; BYTE $0xc8 // addq %rcx, %rax - WORD $0x394c; BYTE $0xf8 // cmpq %r15, %rax - LONG $0x0062850f; WORD $0x0000 // jne LBB33_13, $98(%rip) - LONG $0xd0458b48 // movq $-48(%rbp), %rax - WORD $0x034c; BYTE $0x20 // addq (%rax), %r12 - WORD $0xc931 // xorl %ecx, %ecx - WORD $0x894c; BYTE $0xe3 // movq %r12, %rbx - WORD $0x894c; BYTE $0xef // movq %r13, %rdi - WORD $0x894c; BYTE $0xf8 // movq %r15, %rax - WORD $0x894c; BYTE $0xea // movq %r13, %rdx - WORD $0x894c; BYTE $0xe6 // movq %r12, %rsi - QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90 +LBB29_10: + WORD $0x8948; BYTE $0xd9 // movq %rbx, %rcx + WORD $0xf748; BYTE $0xd1 // notq %rcx + WORD $0x0148; BYTE $0xc8 // addq %rcx, %rax + WORD $0x8948; BYTE $0xc1 // movq %rax, %rcx + WORD $0x094c; BYTE $0xe1 // orq %r12, %rcx + LONG $0x008b840f; WORD $0x0000 // je LBB29_18, $139(%rip) + WORD $0x394c; BYTE $0xe0 // cmpq %r12, %rax + LONG $0x0092850f; WORD $0x0000 // jne LBB29_19, $146(%rip) + LONG $0x005d0349 // addq (%r13), %rbx + LONG $0x20fc8349 // cmpq $32, %r12 + LONG $0x0030820f; WORD $0x0000 // jb LBB29_15, $48(%rip) + LONG $0x90909090 // .p2align 4, 0x90 -LBB33_10: - LONG $0x20f88348 // cmpq $32, %rax - LONG $0x0046820f; WORD $0x0000 // jb LBB33_14, $70(%rip) - LONG $0x066ffec5 // vmovdqu (%rsi), %ymm0 - LONG $0x02f8fdc5 // vpsubb (%rdx), %ymm0, %ymm0 - LONG $0x20c68348 // addq $32, %rsi - LONG $0x20c28348 // addq $32, %rdx - LONG $0xe0c08348 // addq $-32, %rax - LONG $0x20c78348 // addq $32, %rdi +LBB29_13: + LONG $0x036ffec5 // vmovdqu (%rbx), %ymm0 + LONG $0x747dc1c4; BYTE $0x06 // vpcmpeqb (%r14), %ymm0, %ymm0 + LONG $0xc0d7fdc5 // vpmovmskb %ymm0, %eax + WORD $0xf883; BYTE $0xff // cmpl $-1, %eax + LONG $0x0139850f; WORD $0x0000 // jne LBB29_34, $313(%rip) LONG $0x20c38348 // addq $32, %rbx - LONG $0x20c18348 // addq $32, %rcx - LONG $0x177de2c4; BYTE $0xc0 // vptest %ymm0, %ymm0 - LONG $0xffcb840f; WORD $0xffff // je LBB33_10, $-53(%rip) - LONG $0x000090e9; BYTE $0x00 // jmp LBB33_12, $144(%rip) + LONG $0x20c68349 // addq $32, %r14 + LONG $0xe0c48349 // addq $-32, %r12 + LONG $0x1ffc8349 // cmpq $31, %r12 + LONG $0xffd4870f; WORD $0xffff // ja LBB29_13, $-44(%rip) + +LBB29_15: + WORD $0xd889 // movl %ebx, %eax + LONG $0x000fff25; BYTE $0x00 // andl $4095, %eax + WORD $0x8944; BYTE $0xf1 // movl %r14d, %ecx + LONG $0x0fffe181; WORD $0x0000 // andl $4095, %ecx + LONG $0xe0f98148; WORD $0x000f; BYTE $0x00 // cmpq $4064, %rcx + LONG $0x003e870f; WORD $0x0000 // ja LBB29_20, $62(%rip) + LONG $0x000fe13d; BYTE $0x00 // cmpl $4065, %eax + LONG $0x0033830f; WORD $0x0000 // jae LBB29_20, $51(%rip) + LONG $0x036ffec5 // vmovdqu (%rbx), %ymm0 + LONG $0x747dc1c4; BYTE $0x06 // vpcmpeqb (%r14), %ymm0, %ymm0 + LONG $0xc0d7fdc5 // vpmovmskb %ymm0, %eax + WORD $0xf883; BYTE $0xff // cmpl $-1, %eax + WORD $0x940f; BYTE $0xc1 // sete %cl + WORD $0xd0f7 // notl %eax + LONG $0x00009fe9; BYTE $0x00 // jmp LBB29_27, $159(%rip) + WORD $0x9090 // .p2align 4, 0x90 + +LBB29_18: + LONG $0x000001bb; BYTE $0x00 // movl $1, %ebx + LONG $0x0000dae9; BYTE $0x00 // jmp LBB29_36, $218(%rip) LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 -LBB33_13: - WORD $0xdb31 // xorl %ebx, %ebx - LONG $0x00013ce9; BYTE $0x00 // jmp LBB33_33, $316(%rip) - QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90 +LBB29_19: + WORD $0xdb31 // xorl %ebx, %ebx + LONG $0x0000cde9; BYTE $0x00 // jmp LBB29_36, $205(%rip) -LBB33_14: - LONG $0x0fffe381; WORD $0x0000 // andl $4095, %ebx - LONG $0x0fe0fb81; WORD $0x0000 // cmpl $4064, %ebx - LONG $0x003e870f; WORD $0x0000 // ja LBB33_18, $62(%rip) - LONG $0x0fffe781; WORD $0x0000 // andl $4095, %edi - LONG $0x0fe1ff81; WORD $0x0000 // cmpl $4065, %edi - LONG $0x002c830f; WORD $0x0000 // jae LBB33_18, $44(%rip) - LONG $0x066ffec5 // vmovdqu (%rsi), %ymm0 - LONG $0x0274fdc5 // vpcmpeqb (%rdx), %ymm0, %ymm0 - LONG $0xc8d7fdc5 // vpmovmskb %ymm0, %ecx - WORD $0xf983; BYTE $0xff // cmpl $-1, %ecx - LONG $0x00ad840f; WORD $0x0000 // je LBB33_31, $173(%rip) - WORD $0xd1f7 // notl %ecx - WORD $0xbc0f; BYTE $0xc9 // bsfl %ecx, %ecx - LONG $0x000098e9; BYTE $0x00 // jmp LBB33_25, $152(%rip) - QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 +LBB29_20: + LONG $0x10fc8349 // cmpq $16, %r12 + LONG $0x004c820f; WORD $0x0000 // jb LBB29_24, $76(%rip) + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 -LBB33_18: - LONG $0x10f88348 // cmpq $16, %rax - LONG $0x0027820f; WORD $0x0000 // jb LBB33_21, $39(%rip) - LONG $0x6f7ac1c4; WORD $0x0c04 // vmovdqu (%r12,%rcx), %xmm0 - LONG $0xf879c1c4; WORD $0x0d44; BYTE $0x00 // vpsubb (%r13,%rcx), %xmm0, %xmm0 - LONG $0xf0c08348 // addq $-16, %rax - LONG $0x10c18348 // addq $16, %rcx - LONG $0x1779e2c4; BYTE $0xc0 // vptest %xmm0, %xmm0 - LONG $0xffd6840f; WORD $0xffff // je LBB33_18, $-42(%rip) - -LBB33_12: - WORD $0xc031 // xorl %eax, %eax - LONG $0x0000afe9; BYTE $0x00 // jmp LBB33_32, $175(%rip) - -LBB33_21: - WORD $0x8944; BYTE $0xe2 // movl %r12d, %edx - WORD $0xca01 // addl %ecx, %edx - LONG $0x0fffe281; WORD $0x0000 // andl $4095, %edx - LONG $0x0ff0fa81; WORD $0x0000 // cmpl $4080, %edx - LONG $0x0055870f; WORD $0x0000 // ja LBB33_27, $85(%rip) - LONG $0x29148d42 // leal (%rcx,%r13), %edx - LONG $0x0fffe281; WORD $0x0000 // andl $4095, %edx - LONG $0x0ff1fa81; WORD $0x0000 // cmpl $4081, %edx - LONG $0x003f830f; WORD $0x0000 // jae LBB33_27, $63(%rip) - LONG $0x6f7ac1c4; WORD $0x0c04 // vmovdqu (%r12,%rcx), %xmm0 - LONG $0x6f7ac1c4; WORD $0x0d4c; BYTE $0x00 // vmovdqu (%r13,%rcx), %xmm1 - LONG $0xd1f8f9c5 // vpsubb %xmm1, %xmm0, %xmm2 - LONG $0x1779e2c4; BYTE $0xd2 // vptest %xmm2, %xmm2 - LONG $0x001c840f; WORD $0x0000 // je LBB33_31, $28(%rip) - LONG $0xc174f9c5 // vpcmpeqb %xmm1, %xmm0, %xmm0 - LONG $0xc8d7f9c5 // vpmovmskb %xmm0, %ecx - WORD $0xd1f7 // notl %ecx - LONG $0xc9bc0f66 // bsfw %cx, %cx - WORD $0xb70f; BYTE $0xc9 // movzwl %cx, %ecx - -LBB33_25: - WORD $0x3948; BYTE $0xc8 // cmpq %rcx, %rax - WORD $0x960f; BYTE $0xc0 // setbe %al - LONG $0x00004ae9; BYTE $0x00 // jmp LBB33_32, $74(%rip) - -LBB33_31: - WORD $0x01b0 // movb $1, %al - LONG $0x000043e9; BYTE $0x00 // jmp LBB33_32, $67(%rip) - -LBB33_27: +LBB29_21: + LONG $0x036ffac5 // vmovdqu (%rbx), %xmm0 + LONG $0x7479c1c4; BYTE $0x06 // vpcmpeqb (%r14), %xmm0, %xmm0 + LONG $0xc0d7f9c5 // vpmovmskb %xmm0, %eax + LONG $0xfff88366 // cmpw $-1, %ax + LONG $0x0098850f; WORD $0x0000 // jne LBB29_34, $152(%rip) + LONG $0x10c38348 // addq $16, %rbx + LONG $0x10c68349 // addq $16, %r14 + LONG $0xf0c48349 // addq $-16, %r12 + LONG $0x0ffc8349 // cmpq $15, %r12 + LONG $0xffd3870f; WORD $0xffff // ja LBB29_21, $-45(%rip) + WORD $0xd889 // movl %ebx, %eax + LONG $0x000fff25; BYTE $0x00 // andl $4095, %eax + WORD $0x8944; BYTE $0xf1 // movl %r14d, %ecx + LONG $0x0fffe181; WORD $0x0000 // andl $4095, %ecx + +LBB29_24: + LONG $0x0ff0f981; WORD $0x0000 // cmpl $4080, %ecx + LONG $0x0035870f; WORD $0x0000 // ja LBB29_29, $53(%rip) + LONG $0x000ff13d; BYTE $0x00 // cmpl $4081, %eax + LONG $0x002a830f; WORD $0x0000 // jae LBB29_29, $42(%rip) + LONG $0x036ffac5 // vmovdqu (%rbx), %xmm0 + LONG $0x7479c1c4; BYTE $0x06 // vpcmpeqb (%r14), %xmm0, %xmm0 + LONG $0xc0d7f9c5 // vpmovmskb %xmm0, %eax + LONG $0xfff88366 // cmpw $-1, %ax + WORD $0x940f; BYTE $0xc1 // sete %cl + WORD $0xd0f7 // notl %eax + WORD $0xb70f; BYTE $0xc0 // movzwl %ax, %eax + +LBB29_27: + LONG $0xc0bc0f48 // bsfq %rax, %rax + WORD $0x394c; BYTE $0xe0 // cmpq %r12, %rax + WORD $0x930f; BYTE $0xc0 // setae %al + WORD $0xc808 // orb %cl, %al + LONG $0x000033e9; BYTE $0x00 // jmp LBB29_35, $51(%rip) + +LBB29_29: WORD $0x01b0 // movb $1, %al - WORD $0x3949; BYTE $0xcf // cmpq %rcx, %r15 - LONG $0x0038840f; WORD $0x0000 // je LBB33_32, $56(%rip) - WORD $0xff49; BYTE $0xcf // decq %r15 + WORD $0x854d; BYTE $0xe4 // testq %r12, %r12 + LONG $0x0028840f; WORD $0x0000 // je LBB29_35, $40(%rip) + WORD $0xc931 // xorl %ecx, %ecx LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 -LBB33_29: - LONG $0x04b60f41; BYTE $0x0c // movzbl (%r12,%rcx), %eax - LONG $0x0d443a41; BYTE $0x00 // cmpb (%r13,%rcx), %al - WORD $0x940f; BYTE $0xc0 // sete %al - LONG $0x001d850f; WORD $0x0000 // jne LBB33_32, $29(%rip) - LONG $0x01518d48 // leaq $1(%rcx), %rdx - WORD $0x3949; BYTE $0xcf // cmpq %rcx, %r15 - WORD $0x8948; BYTE $0xd1 // movq %rdx, %rcx - LONG $0xffdd850f; WORD $0xffff // jne LBB33_29, $-35(%rip) - QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 +LBB29_31: + LONG $0x0b14b60f // movzbl (%rbx,%rcx), %edx + LONG $0x0e143a41 // cmpb (%r14,%rcx), %dl + LONG $0x0011850f; WORD $0x0000 // jne LBB29_34, $17(%rip) + WORD $0xff48; BYTE $0xc1 // incq %rcx + WORD $0x3949; BYTE $0xcc // cmpq %rcx, %r12 + LONG $0xffe6850f; WORD $0xffff // jne LBB29_31, $-26(%rip) + LONG $0x000002e9; BYTE $0x00 // jmp LBB29_35, $2(%rip) + +LBB29_34: + WORD $0xc031 // xorl %eax, %eax -LBB33_32: +LBB29_35: WORD $0xb60f; BYTE $0xd8 // movzbl %al, %ebx -LBB33_33: - LONG $0xd07d8b4c // movq $-48(%rbp), %r15 +LBB29_36: + LONG $0xc8758b4c // movq $-56(%rbp), %r14 + LONG $0x007d8b49 // movq (%r13), %rdi -LBB33_34: - LONG $0xb8658b4c // movq $-72(%rbp), %r12 - WORD $0x894c; BYTE $0xff // movq %r15, %rdi - WORD $0x894c; BYTE $0xf6 // movq %r14, %rsi +LBB29_37: + LONG $0x08758b49 // movq $8(%r13), %rsi + WORD $0x894c; BYTE $0xfa // movq %r15, %rdx WORD $0xf8c5; BYTE $0x77 // vzeroupper - LONG $0xffcf17e8; BYTE $0xff // callq _advance_ns, $-12521(%rip) + LONG $0xffcf95e8; BYTE $0xff // callq _advance_ns, $-12395(%rip) WORD $0x3a3c // cmpb $58, %al - LONG $0x01b0850f; WORD $0x0000 // jne LBB33_68, $432(%rip) + LONG $0x04b2850f; WORD $0x0000 // jne LBB29_97, $1202(%rip) WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx - LONG $0x0186850f; WORD $0x0000 // jne LBB33_66, $390(%rip) - WORD $0x894c; BYTE $0xff // movq %r15, %rdi - WORD $0x894c; BYTE $0xf6 // movq %r14, %rsi - LONG $0xfff20be8; BYTE $0xff // callq _skip_one_fast, $-3573(%rip) - WORD $0x894c; BYTE $0xff // movq %r15, %rdi - WORD $0x894c; BYTE $0xf6 // movq %r14, %rsi - LONG $0xffcef0e8; BYTE $0xff // callq _advance_ns, $-12560(%rip) + LONG $0x0454850f; WORD $0x0000 // jne LBB29_92, $1108(%rip) + WORD $0x894c; BYTE $0xef // movq %r13, %rdi + WORD $0x894c; BYTE $0xfe // movq %r15, %rsi + LONG $0xfff249e8; BYTE $0xff // callq _skip_one_fast, $-3511(%rip) + LONG $0x007d8b49 // movq (%r13), %rdi + LONG $0x08758b49 // movq $8(%r13), %rsi + WORD $0x894c; BYTE $0xfa // movq %r15, %rdx + LONG $0xffcf69e8; BYTE $0xff // callq _advance_ns, $-12439(%rip) WORD $0x2c3c // cmpb $44, %al - LONG $0xfda8840f; WORD $0xffff // je LBB33_4, $-600(%rip) - LONG $0x000184e9; BYTE $0x00 // jmp LBB33_68, $388(%rip) + LONG $0xfdd1840f; WORD $0xffff // je LBB29_6, $-559(%rip) + LONG $0x000462e9; BYTE $0x00 // jmp LBB29_94, $1122(%rip) -LBB33_37: - QUAD $0x00000000c845c748 // movq $0, $-56(%rbp) - LONG $0xd04d8b48 // movq $-48(%rbp), %rcx - WORD $0x8b48; BYTE $0x09 // movq (%rcx), %rcx - WORD $0x0149; BYTE $0xcc // addq %rcx, %r12 - LONG $0xc065894c // movq %r12, $-64(%rbp) - LONG $0x01348d48 // leaq (%rcx,%rax), %rsi - WORD $0xff48; BYTE $0xce // decq %rsi - LONG $0x2f1c8d4b // leaq (%r15,%r13), %rbx - WORD $0x3949; BYTE $0xf4 // cmpq %rsi, %r12 - LONG $0x00c1830f; WORD $0x0000 // jae LBB33_57, $193(%rip) - WORD $0x854d; BYTE $0xff // testq %r15, %r15 - LONG $0x00b88e0f; WORD $0x0000 // jle LBB33_57, $184(%rip) - LONG $0xd07d8b4c // movq $-48(%rbp), %r15 - LONG $0xa8758948 // movq %rsi, $-88(%rbp) +LBB29_40: + QUAD $0x00000000d045c748 // movq $0, $-48(%rbp) + LONG $0x007d8b49 // movq (%r13), %rdi + WORD $0x0148; BYTE $0xfb // addq %rdi, %rbx + LONG $0x07448d4c; BYTE $0xff // leaq $-1(%rdi,%rax), %r8 + LONG $0x26148d4f // leaq (%r14,%r12), %r10 + WORD $0x854d; BYTE $0xe4 // testq %r12, %r12 + LONG $0x03638e0f; WORD $0x0000 // jle LBB29_84, $867(%rip) + WORD $0x3949; BYTE $0xd8 // cmpq %rbx, %r8 + LONG $0x035a860f; WORD $0x0000 // jbe LBB29_84, $858(%rip) + +LBB29_42: + WORD $0x038a // movb (%rbx), %al + WORD $0x5c3c // cmpb $92, %al + LONG $0x0058850f; WORD $0x0000 // jne LBB29_47, $88(%rip) + WORD $0x894c; BYTE $0xc1 // movq %r8, %rcx + WORD $0x2948; BYTE $0xd9 // subq %rbx, %rcx + LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax + WORD $0x8548; BYTE $0xc9 // testq %rcx, %rcx + LONG $0x04948e0f; WORD $0x0000 // jle LBB29_104, $1172(%rip) + LONG $0x0153b60f // movzbl $1(%rbx), %edx + LONG $0x17358d48; WORD $0x009d; BYTE $0x00 // leaq $40215(%rip), %rsi /* __UnquoteTab(%rip) */ + LONG $0x321c8a44 // movb (%rdx,%rsi), %r11b + LONG $0xfffb8041 // cmpb $-1, %r11b + LONG $0x003d840f; WORD $0x0000 // je LBB29_49, $61(%rip) + WORD $0x8445; BYTE $0xdb // testb %r11b, %r11b + LONG $0x0460840f; WORD $0x0000 // je LBB29_102, $1120(%rip) + LONG $0xd05d8844 // movb %r11b, $-48(%rbp) + LONG $0x02c38348 // addq $2, %rbx + LONG $0x000001b9; BYTE $0x00 // movl $1, %ecx + LONG $0x0d4c8d4c; BYTE $0xd0 // leaq $-48(%rbp,%rcx), %r9 + WORD $0x394d; BYTE $0xd6 // cmpq %r10, %r14 + LONG $0x012c820f; WORD $0x0000 // jb LBB29_60, $300(%rip) + LONG $0x0002d9e9; BYTE $0x00 // jmp LBB29_68, $729(%rip) + +LBB29_47: + WORD $0x3a41; BYTE $0x06 // cmpb (%r14), %al + LONG $0x0306850f; WORD $0x0000 // jne LBB29_85, $774(%rip) + WORD $0xff48; BYTE $0xc3 // incq %rbx + WORD $0xff49; BYTE $0xc6 // incq %r14 + LONG $0x0002d2e9; BYTE $0x00 // jmp LBB29_70, $722(%rip) -LBB33_40: - LONG $0x04b60f41; BYTE $0x24 // movzbl (%r12), %eax - WORD $0x5c3c // cmpb $92, %al - LONG $0x005e850f; WORD $0x0000 // jne LBB33_48, $94(%rip) - LONG $0xc07d8d48 // leaq $-64(%rbp), %rdi - LONG $0xc8558d48 // leaq $-56(%rbp), %rdx - LONG $0x0026eee8; BYTE $0x00 // callq _unescape, $9966(%rip) - WORD $0x8548; BYTE $0xc0 // testq %rax, %rax - LONG $0x0156880f; WORD $0x0000 // js LBB33_71, $342(%rip) - LONG $0x280c8d48 // leaq (%rax,%rbp), %rcx - LONG $0xc8c18348 // addq $-56, %rcx - WORD $0x3949; BYTE $0xdd // cmpq %rbx, %r13 - LONG $0x0050830f; WORD $0x0000 // jae LBB33_51, $80(%rip) - WORD $0x8548; BYTE $0xc0 // testq %rax, %rax - LONG $0x0047840f; WORD $0x0000 // je LBB33_51, $71(%rip) - LONG $0xc8458d48 // leaq $-56(%rbp), %rax +LBB29_49: + LONG $0x03f98348 // cmpq $3, %rcx + LONG $0x04318e0f; WORD $0x0000 // jle LBB29_103, $1073(%rip) + WORD $0x438b; BYTE $0x02 // movl $2(%rbx), %eax + WORD $0xc289 // movl %eax, %edx + WORD $0xd2f7 // notl %edx + LONG $0xcfd0b08d; WORD $0xcfcf // leal $-808464432(%rax), %esi + LONG $0x8080e281; WORD $0x8080 // andl $-2139062144, %edx + WORD $0xf285 // testl %esi, %edx + LONG $0x03f7850f; WORD $0x0000 // jne LBB29_101, $1015(%rip) + LONG $0x1919b08d; WORD $0x1919 // leal $421075225(%rax), %esi + WORD $0xc609 // orl %eax, %esi + LONG $0x8080c6f7; WORD $0x8080 // testl $-2139062144, %esi + LONG $0x03e3850f; WORD $0x0000 // jne LBB29_101, $995(%rip) + WORD $0xc689 // movl %eax, %esi + LONG $0x7f7fe681; WORD $0x7f7f // andl $2139062143, %esi + LONG $0xc0c0b941; WORD $0xc0c0 // movl $-1061109568, %r9d + WORD $0x2941; BYTE $0xf1 // subl %esi, %r9d + LONG $0x469e8d44; WORD $0x4646; BYTE $0x46 // leal $1179010630(%rsi), %r11d + WORD $0x2141; BYTE $0xd1 // andl %edx, %r9d + WORD $0x8545; BYTE $0xd9 // testl %r11d, %r9d + LONG $0x03bf850f; WORD $0x0000 // jne LBB29_101, $959(%rip) + LONG $0xe0e0b941; WORD $0xe0e0 // movl $-522133280, %r9d + WORD $0x2941; BYTE $0xf1 // subl %esi, %r9d + LONG $0x3939c681; WORD $0x3939 // addl $960051513, %esi + WORD $0x2144; BYTE $0xca // andl %r9d, %edx + WORD $0xf285 // testl %esi, %edx + LONG $0x03a5850f; WORD $0x0000 // jne LBB29_101, $933(%rip) + WORD $0xc80f // bswapl %eax + WORD $0xc289 // movl %eax, %edx + WORD $0xeac1; BYTE $0x04 // shrl $4, %edx + WORD $0xd2f7 // notl %edx + LONG $0x0101e281; WORD $0x0101 // andl $16843009, %edx + WORD $0x148d; BYTE $0xd2 // leal (%rdx,%rdx,8), %edx + LONG $0x0f0f0f25; BYTE $0x0f // andl $252645135, %eax + WORD $0xd001 // addl %edx, %eax + WORD $0x8941; BYTE $0xc3 // movl %eax, %r11d + LONG $0x04ebc141 // shrl $4, %r11d + WORD $0x0941; BYTE $0xc3 // orl %eax, %r11d + WORD $0x8944; BYTE $0xde // movl %r11d, %esi + WORD $0xeec1; BYTE $0x08 // shrl $8, %esi + LONG $0xff00e681; WORD $0x0000 // andl $65280, %esi + LONG $0xc3b60f41 // movzbl %r11b, %eax + WORD $0xf009 // orl %esi, %eax + LONG $0x064b8d4c // leaq $6(%rbx), %r9 + WORD $0xf883; BYTE $0x7f // cmpl $127, %eax + LONG $0x00ab860f; WORD $0x0000 // jbe LBB29_72, $171(%rip) + LONG $0x0007ff3d; BYTE $0x00 // cmpl $2047, %eax + LONG $0x00ae860f; WORD $0x0000 // jbe LBB29_73, $174(%rip) + WORD $0x8944; BYTE $0xda // movl %r11d, %edx + LONG $0x0000e281; WORD $0x00f8 // andl $16252928, %edx + LONG $0x0000fa81; WORD $0x00d8 // cmpl $14155776, %edx + LONG $0x00ba840f; WORD $0x0000 // je LBB29_74, $186(%rip) + WORD $0xeec1; BYTE $0x0c // shrl $12, %esi + LONG $0xe0ce8040 // orb $-32, %sil + LONG $0xd0758840 // movb %sil, $-48(%rbp) + WORD $0xe8c1; BYTE $0x06 // shrl $6, %eax + WORD $0x3f24 // andb $63, %al + WORD $0x800c // orb $-128, %al + WORD $0x4588; BYTE $0xd1 // movb %al, $-47(%rbp) + LONG $0x3fe38041 // andb $63, %r11b + LONG $0x80cb8041 // orb $-128, %r11b + LONG $0xd25d8844 // movb %r11b, $-46(%rbp) + LONG $0x000003b9; BYTE $0x00 // movl $3, %ecx + WORD $0x8941; BYTE $0xf3 // movl %esi, %r11d -LBB33_45: - LONG $0x55b60f41; BYTE $0x00 // movzbl (%r13), %edx - WORD $0x103a // cmpb (%rax), %dl - LONG $0x003a850f; WORD $0x0000 // jne LBB33_52, $58(%rip) - WORD $0xff49; BYTE $0xc5 // incq %r13 - WORD $0xff48; BYTE $0xc0 // incq %rax - WORD $0x3949; BYTE $0xdd // cmpq %rbx, %r13 - LONG $0x002b830f; WORD $0x0000 // jae LBB33_52, $43(%rip) - WORD $0x3948; BYTE $0xc8 // cmpq %rcx, %rax - LONG $0xffdb820f; WORD $0xffff // jb LBB33_45, $-37(%rip) - LONG $0x00001de9; BYTE $0x00 // jmp LBB33_52, $29(%rip) +LBB29_58: + WORD $0x894c; BYTE $0xcb // movq %r9, %rbx + LONG $0x0d4c8d4c; BYTE $0xd0 // leaq $-48(%rbp,%rcx), %r9 + WORD $0x394d; BYTE $0xd6 // cmpq %r10, %r14 + LONG $0x01b2830f; WORD $0x0000 // jae LBB29_68, $434(%rip) -LBB33_48: - LONG $0x00453a41 // cmpb (%r13), %al - LONG $0x0052850f; WORD $0x0000 // jne LBB33_60, $82(%rip) - WORD $0xff49; BYTE $0xc4 // incq %r12 - LONG $0xc065894c // movq %r12, $-64(%rbp) - WORD $0xff49; BYTE $0xc5 // incq %r13 - LONG $0x000015e9; BYTE $0x00 // jmp LBB33_54, $21(%rip) +LBB29_60: + LONG $0xd0458d48 // leaq $-48(%rbp), %rax + WORD $0x3949; BYTE $0xc1 // cmpq %rax, %r9 + LONG $0x01a5860f; WORD $0x0000 // jbe LBB29_68, $421(%rip) + WORD $0x3845; BYTE $0x1e // cmpb %r11b, (%r14) + LONG $0x019c850f; WORD $0x0000 // jne LBB29_68, $412(%rip) + WORD $0xff49; BYTE $0xc6 // incq %r14 + LONG $0xd1558d48 // leaq $-47(%rbp), %rdx + WORD $0x894c; BYTE $0xf6 // movq %r14, %rsi -LBB33_51: - LONG $0xc8458d48 // leaq $-56(%rbp), %rax +LBB29_63: + WORD $0x8949; BYTE $0xf6 // movq %rsi, %r14 + WORD $0x8948; BYTE $0xd1 // movq %rdx, %rcx + WORD $0x394c; BYTE $0xca // cmpq %r9, %rdx + LONG $0x0187830f; WORD $0x0000 // jae LBB29_69, $391(%rip) + WORD $0x394d; BYTE $0xd6 // cmpq %r10, %r14 + LONG $0x017e830f; WORD $0x0000 // jae LBB29_69, $382(%rip) + LONG $0x06b60f41 // movzbl (%r14), %eax + LONG $0x01768d49 // leaq $1(%r14), %rsi + LONG $0x01518d48 // leaq $1(%rcx), %rdx + WORD $0x013a // cmpb (%rcx), %al + LONG $0xffd4840f; WORD $0xffff // je LBB29_63, $-44(%rip) + LONG $0x000165e9; BYTE $0x00 // jmp LBB29_69, $357(%rip) + +LBB29_72: + LONG $0xd05d8844 // movb %r11b, $-48(%rbp) + LONG $0x000001b9; BYTE $0x00 // movl $1, %ecx + LONG $0xffff90e9; BYTE $0xff // jmp LBB29_58, $-112(%rip) + +LBB29_73: + WORD $0xe8c1; BYTE $0x06 // shrl $6, %eax + WORD $0xc00c // orb $-64, %al + WORD $0x4588; BYTE $0xd0 // movb %al, $-48(%rbp) + LONG $0x3fe38041 // andb $63, %r11b + LONG $0x80cb8041 // orb $-128, %r11b + LONG $0xd15d8844 // movb %r11b, $-47(%rbp) + LONG $0x000002b9; BYTE $0x00 // movl $2, %ecx + WORD $0x8941; BYTE $0xc3 // movl %eax, %r11d + LONG $0xffff6fe9; BYTE $0xff // jmp LBB29_58, $-145(%rip) + +LBB29_74: + LONG $0x06f98348 // cmpq $6, %rcx + LONG $0x02b88c0f; WORD $0x0000 // jl LBB29_106, $696(%rip) + LONG $0x00dbff3d; BYTE $0x00 // cmpl $56319, %eax + LONG $0x02ad870f; WORD $0x0000 // ja LBB29_106, $685(%rip) + LONG $0x5c398041 // cmpb $92, (%r9) + LONG $0x02a3850f; WORD $0x0000 // jne LBB29_106, $675(%rip) + LONG $0x75077b80 // cmpb $117, $7(%rbx) + LONG $0x0299850f; WORD $0x0000 // jne LBB29_106, $665(%rip) + LONG $0x084b8d4c // leaq $8(%rbx), %r9 + WORD $0x4b8b; BYTE $0x08 // movl $8(%rbx), %ecx + WORD $0xca89 // movl %ecx, %edx + WORD $0xd2f7 // notl %edx + LONG $0xcfd0b18d; WORD $0xcfcf // leal $-808464432(%rcx), %esi + LONG $0x8080e281; WORD $0x8080 // andl $-2139062144, %edx + WORD $0xf285 // testl %esi, %edx + LONG $0x026e850f; WORD $0x0000 // jne LBB29_105, $622(%rip) + LONG $0x1919b18d; WORD $0x1919 // leal $421075225(%rcx), %esi + WORD $0xce09 // orl %ecx, %esi + LONG $0x8080c6f7; WORD $0x8080 // testl $-2139062144, %esi + LONG $0x025a850f; WORD $0x0000 // jne LBB29_105, $602(%rip) + WORD $0xce89 // movl %ecx, %esi + LONG $0x7f7fe681; WORD $0x7f7f // andl $2139062143, %esi + LONG $0xc0c0bb41; WORD $0xc0c0 // movl $-1061109568, %r11d + WORD $0x2941; BYTE $0xf3 // subl %esi, %r11d + LONG $0x46a68d44; WORD $0x4646; BYTE $0x46 // leal $1179010630(%rsi), %r12d + WORD $0x2141; BYTE $0xd3 // andl %edx, %r11d + WORD $0x8545; BYTE $0xe3 // testl %r12d, %r11d + LONG $0x0236850f; WORD $0x0000 // jne LBB29_105, $566(%rip) + LONG $0xe0e0bb41; WORD $0xe0e0 // movl $-522133280, %r11d + WORD $0x2941; BYTE $0xf3 // subl %esi, %r11d + LONG $0x3939c681; WORD $0x3939 // addl $960051513, %esi + WORD $0x2144; BYTE $0xda // andl %r11d, %edx + WORD $0xf285 // testl %esi, %edx + LONG $0x021c850f; WORD $0x0000 // jne LBB29_105, $540(%rip) + WORD $0xc90f // bswapl %ecx + WORD $0xca89 // movl %ecx, %edx + WORD $0xeac1; BYTE $0x04 // shrl $4, %edx + WORD $0xd2f7 // notl %edx + LONG $0x0101e281; WORD $0x0101 // andl $16843009, %edx + WORD $0x148d; BYTE $0xd2 // leal (%rdx,%rdx,8), %edx + LONG $0x0f0fe181; WORD $0x0f0f // andl $252645135, %ecx + WORD $0xd101 // addl %edx, %ecx + WORD $0xca89 // movl %ecx, %edx + WORD $0xeac1; BYTE $0x04 // shrl $4, %edx + WORD $0xca09 // orl %ecx, %edx + WORD $0xd189 // movl %edx, %ecx + LONG $0x0000e181; WORD $0x00fc // andl $16515072, %ecx + LONG $0x0000f981; WORD $0x00dc // cmpl $14417920, %ecx + LONG $0x01f3850f; WORD $0x0000 // jne LBB29_106, $499(%rip) + WORD $0xd189 // movl %edx, %ecx + WORD $0xe9c1; BYTE $0x08 // shrl $8, %ecx + LONG $0xff00e181; WORD $0x0000 // andl $65280, %ecx + WORD $0xb60f; BYTE $0xd2 // movzbl %dl, %edx + WORD $0xca09 // orl %ecx, %edx + WORD $0xe0c1; BYTE $0x0a // shll $10, %eax + LONG $0x0010848d; WORD $0xa024; BYTE $0xfc // leal $-56613888(%rax,%rdx), %eax + WORD $0x8941; BYTE $0xc3 // movl %eax, %r11d + LONG $0x12ebc141 // shrl $18, %r11d + LONG $0xf0cb8041 // orb $-16, %r11b + LONG $0xd05d8844 // movb %r11b, $-48(%rbp) + WORD $0xc189 // movl %eax, %ecx + WORD $0xe9c1; BYTE $0x0c // shrl $12, %ecx + WORD $0xe180; BYTE $0x3f // andb $63, %cl + WORD $0xc980; BYTE $0x80 // orb $-128, %cl + WORD $0x4d88; BYTE $0xd1 // movb %cl, $-47(%rbp) + WORD $0xc189 // movl %eax, %ecx + WORD $0xe9c1; BYTE $0x06 // shrl $6, %ecx + WORD $0xe180; BYTE $0x3f // andb $63, %cl + WORD $0xc980; BYTE $0x80 // orb $-128, %cl + WORD $0x4d88; BYTE $0xd2 // movb %cl, $-46(%rbp) + WORD $0x3f24 // andb $63, %al + WORD $0x800c // orb $-128, %al + WORD $0x4588; BYTE $0xd3 // movb %al, $-45(%rbp) + LONG $0x0cc38348 // addq $12, %rbx + LONG $0x000004b9; BYTE $0x00 // movl $4, %ecx + LONG $0x0d4c8d4c; BYTE $0xd0 // leaq $-48(%rbp,%rcx), %r9 + WORD $0x394d; BYTE $0xd6 // cmpq %r10, %r14 + LONG $0xfe4e820f; WORD $0xffff // jb LBB29_60, $-434(%rip) -LBB33_52: - WORD $0x3948; BYTE $0xc8 // cmpq %rcx, %rax - LONG $0x0036850f; WORD $0x0000 // jne LBB33_60, $54(%rip) - LONG $0xc0658b4c // movq $-64(%rbp), %r12 - LONG $0xa8758b48 // movq $-88(%rbp), %rsi +LBB29_68: + LONG $0xd04d8d48 // leaq $-48(%rbp), %rcx -LBB33_54: - WORD $0x3949; BYTE $0xf4 // cmpq %rsi, %r12 - LONG $0x0012830f; WORD $0x0000 // jae LBB33_58, $18(%rip) - WORD $0x3949; BYTE $0xdd // cmpq %rbx, %r13 - LONG $0xff55820f; WORD $0xffff // jb LBB33_40, $-171(%rip) - LONG $0x000004e9; BYTE $0x00 // jmp LBB33_58, $4(%rip) +LBB29_69: + WORD $0x394c; BYTE $0xc9 // cmpq %r9, %rcx + LONG $0x0029850f; WORD $0x0000 // jne LBB29_85, $41(%rip) -LBB33_57: - LONG $0xd07d8b4c // movq $-48(%rbp), %r15 +LBB29_70: + WORD $0x3949; BYTE $0xd8 // cmpq %rbx, %r8 + LONG $0x0009860f; WORD $0x0000 // jbe LBB29_84, $9(%rip) + WORD $0x394d; BYTE $0xd6 // cmpq %r10, %r14 + LONG $0xfca6820f; WORD $0xffff // jb LBB29_42, $-858(%rip) -LBB33_58: - WORD $0x3149; BYTE $0xf4 // xorq %rsi, %r12 - WORD $0x3149; BYTE $0xdd // xorq %rbx, %r13 +LBB29_84: + WORD $0x3149; BYTE $0xd8 // xorq %rbx, %r8 + WORD $0x314d; BYTE $0xd6 // xorq %r10, %r14 WORD $0xdb31 // xorl %ebx, %ebx - WORD $0x094d; BYTE $0xe5 // orq %r12, %r13 + WORD $0x094d; BYTE $0xc6 // orq %r8, %r14 WORD $0x940f; BYTE $0xc3 // sete %bl - LONG $0xfffeb8e9; BYTE $0xff // jmp LBB33_34, $-328(%rip) + LONG $0xc8758b4c // movq $-56(%rbp), %r14 + LONG $0xfffc1de9; BYTE $0xff // jmp LBB29_37, $-995(%rip) -LBB33_60: - WORD $0xdb31 // xorl %ebx, %ebx - LONG $0xfffeb1e9; BYTE $0xff // jmp LBB33_34, $-335(%rip) +LBB29_85: + WORD $0xdb31 // xorl %ebx, %ebx + LONG $0xc8758b4c // movq $-56(%rbp), %r14 + LONG $0xfffc12e9; BYTE $0xff // jmp LBB29_37, $-1006(%rip) + LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 + +LBB29_86: + WORD $0x5b3c // cmpb $91, %al + LONG $0x00cd850f; WORD $0x0000 // jne LBB29_97, $205(%rip) + LONG $0x08468b49 // movq $8(%r14), %rax + WORD $0x8b48; BYTE $0x18 // movq (%rax), %rbx + WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx + LONG $0x00d6880f; WORD $0x0000 // js LBB29_99, $214(%rip) + LONG $0x007d8b49 // movq (%r13), %rdi + LONG $0x08758b49 // movq $8(%r13), %rsi + WORD $0x894c; BYTE $0xfa // movq %r15, %rdx + LONG $0xffcb88e8; BYTE $0xff // callq _advance_ns, $-13432(%rip) + WORD $0x5d3c // cmpb $93, %al + LONG $0x008e840f; WORD $0x0000 // je LBB29_95, $142(%rip) + WORD $0xff49; BYTE $0x0f // decq (%r15) + WORD $0xff48; BYTE $0xc3 // incq %rbx QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90 -LBB33_61: - WORD $0xf980; BYTE $0x02 // cmpb $2, %cl - LONG $0x0068850f; WORD $0x0000 // jne LBB33_68, $104(%rip) - WORD $0x5b3c // cmpb $91, %al - LONG $0x0060850f; WORD $0x0000 // jne LBB33_68, $96(%rip) - LONG $0x24448b49; BYTE $0x08 // movq $8(%r12), %rax - WORD $0x8b48; BYTE $0x18 // movq (%rax), %rbx - WORD $0xff48; BYTE $0xc3 // incq %rbx - LONG $0x90909090 // .p2align 4, 0x90 +LBB29_90: + WORD $0xff48; BYTE $0xcb // decq %rbx + WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx + LONG $0x00348e0f; WORD $0x0000 // jle LBB29_92, $52(%rip) + WORD $0x894c; BYTE $0xef // movq %r13, %rdi + WORD $0x894c; BYTE $0xfe // movq %r15, %rsi + LONG $0xffee29e8; BYTE $0xff // callq _skip_one_fast, $-4567(%rip) + LONG $0x007d8b49 // movq (%r13), %rdi + LONG $0x08758b49 // movq $8(%r13), %rsi + WORD $0x894c; BYTE $0xfa // movq %r15, %rdx + LONG $0xffcb49e8; BYTE $0xff // callq _advance_ns, $-13495(%rip) + WORD $0x2c3c // cmpb $44, %al + LONG $0xffd1840f; WORD $0xffff // je LBB29_90, $-47(%rip) + LONG $0x000059e9; BYTE $0x00 // jmp LBB29_96, $89(%rip) + QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90 -LBB33_64: - WORD $0xff48; BYTE $0xcb // decq %rbx - WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx - LONG $0x00248e0f; WORD $0x0000 // jle LBB33_66, $36(%rip) - WORD $0x894c; BYTE $0xff // movq %r15, %rdi - WORD $0x894c; BYTE $0xf6 // movq %r14, %rsi - LONG $0xfff0a9e8; BYTE $0xff // callq _skip_one_fast, $-3927(%rip) - WORD $0x894c; BYTE $0xff // movq %r15, %rdi - WORD $0x894c; BYTE $0xf6 // movq %r14, %rsi - LONG $0xffcd8ee8; BYTE $0xff // callq _advance_ns, $-12914(%rip) - WORD $0x2c3c // cmpb $44, %al - LONG $0xffd6840f; WORD $0xffff // je LBB33_64, $-42(%rip) - LONG $0x000022e9; BYTE $0x00 // jmp LBB33_68, $34(%rip) - BYTE $0x90 // .p2align 4, 0x90 +LBB29_92: + LONG $0x10c68349 // addq $16, %r14 + LONG $0xb8458b48 // movq $-72(%rbp), %rax + WORD $0x3949; BYTE $0xc6 // cmpq %rax, %r14 + LONG $0xb04d8b48 // movq $-80(%rbp), %rcx + LONG $0xf941850f; WORD $0xffff // jne LBB29_2, $-1727(%rip) -LBB33_66: - LONG $0x10c48349 // addq $16, %r12 - LONG $0xa0458b48 // movq $-96(%rbp), %rax - WORD $0x3949; BYTE $0xc4 // cmpq %rax, %r12 - LONG $0xfbf1850f; WORD $0xffff // jne LBB33_2, $-1039(%rip) +LBB29_93: + QUAD $0xfffff8f3056ff9c5 // vmovdqa $-1805(%rip), %xmm0 /* LCPI29_0(%rip) */ + LONG $0x017ffac5 // vmovdqu %xmm0, (%rcx) + WORD $0x8948; BYTE $0xcf // movq %rcx, %rdi + WORD $0x894c; BYTE $0xee // movq %r13, %rsi + WORD $0x894c; BYTE $0xfa // movq %r15, %rdx + WORD $0xc931 // xorl %ecx, %ecx + LONG $0xffdb3fe8; BYTE $0xff // callq _fsm_exec, $-9409(%rip) + LONG $0x000029e9; BYTE $0x00 // jmp LBB29_98, $41(%rip) -LBB33_67: - WORD $0x894c; BYTE $0xff // movq %r15, %rdi - WORD $0x894c; BYTE $0xf6 // movq %r14, %rsi - LONG $0xfff074e8; BYTE $0xff // callq _skip_one_fast, $-3980(%rip) - LONG $0x00000ae9; BYTE $0x00 // jmp LBB33_69, $10(%rip) +LBB29_94: + WORD $0x7d3c // cmpb $125, %al + LONG $0x0017850f; WORD $0x0000 // jne LBB29_97, $23(%rip) + +LBB29_95: + WORD $0xff49; BYTE $0x0f // decq (%r15) + LONG $0xdfc0c748; WORD $0xffff; BYTE $0xff // movq $-33, %rax + LONG $0x000012e9; BYTE $0x00 // jmp LBB29_98, $18(%rip) + +LBB29_96: + WORD $0x5d3c // cmpb $93, %al + LONG $0xffe9840f; WORD $0xffff // je LBB29_95, $-23(%rip) -LBB33_68: - WORD $0xff49; BYTE $0x0e // decq (%r14) +LBB29_97: + WORD $0xff49; BYTE $0x0f // decq (%r15) LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq $-2, %rax -LBB33_69: - LONG $0x38c48348 // addq $56, %rsp +LBB29_98: + LONG $0x28c48348 // addq $40, %rsp BYTE $0x5b // popq %rbx WORD $0x5c41 // popq %r12 WORD $0x5d41 // popq %r13 @@ -9016,120 +8737,146 @@ LBB33_69: BYTE $0x5d // popq %rbp BYTE $0xc3 // retq -LBB33_70: - LONG $0xd0458b48 // movq $-48(%rbp), %rax - LONG $0x08408b48 // movq $8(%rax), %rax - WORD $0x8949; BYTE $0x06 // movq %rax, (%r14) +LBB29_99: + WORD $0xff49; BYTE $0x0f // decq (%r15) + LONG $0xdec0c748; WORD $0xffff; BYTE $0xff // movq $-34, %rax + LONG $0xffffe2e9; BYTE $0xff // jmp LBB29_98, $-30(%rip) + +LBB29_100: + LONG $0x08458b49 // movq $8(%r13), %rax + WORD $0x8949; BYTE $0x07 // movq %rax, (%r15) LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax - LONG $0xffffdae9; BYTE $0xff // jmp LBB33_69, $-38(%rip) + LONG $0xffffcfe9; BYTE $0xff // jmp LBB29_98, $-49(%rip) -LBB33_71: - LONG $0xc04d8b48 // movq $-64(%rbp), %rcx - WORD $0x2b49; BYTE $0x0f // subq (%r15), %rcx - WORD $0x8949; BYTE $0x0e // movq %rcx, (%r14) - LONG $0xffffcbe9; BYTE $0xff // jmp LBB33_69, $-53(%rip) +LBB29_101: + LONG $0x02c38348 // addq $2, %rbx + LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq $-2, %rax + LONG $0x000012e9; BYTE $0x00 // jmp LBB29_104, $18(%rip) + +LBB29_102: + WORD $0xff48; BYTE $0xc3 // incq %rbx + LONG $0xfdc0c748; WORD $0xffff; BYTE $0xff // movq $-3, %rax + LONG $0x000003e9; BYTE $0x00 // jmp LBB29_104, $3(%rip) + +LBB29_103: + WORD $0xff48; BYTE $0xc3 // incq %rbx + +LBB29_104: + WORD $0x2948; BYTE $0xfb // subq %rdi, %rbx + WORD $0x8949; BYTE $0x1f // movq %rbx, (%r15) + LONG $0xffffa2e9; BYTE $0xff // jmp LBB29_98, $-94(%rip) + +LBB29_105: + LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq $-2, %rax + LONG $0x000007e9; BYTE $0x00 // jmp LBB29_107, $7(%rip) + +LBB29_106: + LONG $0xfcc0c748; WORD $0xffff; BYTE $0xff // movq $-4, %rax + +LBB29_107: + WORD $0x894c; BYTE $0xcb // movq %r9, %rbx + LONG $0xffffdae9; BYTE $0xff // jmp LBB29_104, $-38(%rip) + QUAD $0x9090909090909090 // .p2align 4, 0x90 - // .p2align 4, 0x90 _validate_utf8: - BYTE $0x55 // pushq %rbp - WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp - WORD $0x5741 // pushq %r15 - WORD $0x5641 // pushq %r14 - WORD $0x5441 // pushq %r12 - BYTE $0x53 // pushq %rbx - BYTE $0x50 // pushq %rax - WORD $0x8b4c; BYTE $0x17 // movq (%rdi), %r10 - LONG $0x085f8b4c // movq $8(%rdi), %r11 - WORD $0x8b48; BYTE $0x0e // movq (%rsi), %rcx - WORD $0x014c; BYTE $0xd1 // addq %r10, %rcx - LONG $0x1a048d4f // leaq (%r10,%r11), %r8 - LONG $0xfdc08349 // addq $-3, %r8 - LONG $0x00000de9; BYTE $0x00 // jmp LBB34_1, $13(%rip) - QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90 + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5741 // pushq %r15 + WORD $0x5641 // pushq %r14 + WORD $0x5441 // pushq %r12 + BYTE $0x53 // pushq %rbx + BYTE $0x50 // pushq %rax + WORD $0x8b4c; BYTE $0x17 // movq (%rdi), %r10 + LONG $0x085f8b4c // movq $8(%rdi), %r11 + WORD $0x8b48; BYTE $0x0e // movq (%rsi), %rcx + WORD $0x014c; BYTE $0xd1 // addq %r10, %rcx + LONG $0x1a448d4f; BYTE $0xfd // leaq $-3(%r10,%r11), %r8 + LONG $0x000010e9; BYTE $0x00 // jmp LBB30_1, $16(%rip) + QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 -LBB34_19: +LBB30_19: WORD $0x0148; BYTE $0xd9 // addq %rbx, %rcx -LBB34_1: +LBB30_1: WORD $0x394c; BYTE $0xc1 // cmpq %r8, %rcx - LONG $0x00e1830f; WORD $0x0000 // jae LBB34_2, $225(%rip) + LONG $0x00e1830f; WORD $0x0000 // jae LBB30_2, $225(%rip) LONG $0x000001bb; BYTE $0x00 // movl $1, %ebx WORD $0x3980; BYTE $0x00 // cmpb $0, (%rcx) - LONG $0xffe6890f; WORD $0xffff // jns LBB34_19, $-26(%rip) + LONG $0xffe6890f; WORD $0xffff // jns LBB30_19, $-26(%rip) WORD $0x018b // movl (%rcx), %eax WORD $0xc789 // movl %eax, %edi LONG $0xc0f0e781; WORD $0x00c0 // andl $12632304, %edi LONG $0x80e0ff81; WORD $0x0080 // cmpl $8421600, %edi - LONG $0x0030850f; WORD $0x0000 // jne LBB34_10, $48(%rip) + LONG $0x0030850f; WORD $0x0000 // jne LBB30_10, $48(%rip) WORD $0xc789 // movl %eax, %edi LONG $0x200fe781; WORD $0x0000 // andl $8207, %edi LONG $0x200dff81; WORD $0x0000 // cmpl $8205, %edi - LONG $0x001c840f; WORD $0x0000 // je LBB34_10, $28(%rip) + LONG $0x001c840f; WORD $0x0000 // je LBB30_10, $28(%rip) LONG $0x000003bb; BYTE $0x00 // movl $3, %ebx WORD $0xff85 // testl %edi, %edi - LONG $0xffaf850f; WORD $0xffff // jne LBB34_19, $-81(%rip) + LONG $0xffaf850f; WORD $0xffff // jne LBB30_19, $-81(%rip) QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 -LBB34_10: +LBB30_10: WORD $0xc789 // movl %eax, %edi LONG $0xc0e0e781; WORD $0x0000 // andl $49376, %edi LONG $0x80c0ff81; WORD $0x0000 // cmpl $32960, %edi - LONG $0x0010850f; WORD $0x0000 // jne LBB34_12, $16(%rip) + LONG $0x0010850f; WORD $0x0000 // jne LBB30_12, $16(%rip) WORD $0xc789 // movl %eax, %edi LONG $0x000002bb; BYTE $0x00 // movl $2, %ebx WORD $0xe783; BYTE $0x1e // andl $30, %edi - LONG $0xff7c850f; WORD $0xffff // jne LBB34_19, $-132(%rip) + LONG $0xff7c850f; WORD $0xffff // jne LBB30_19, $-132(%rip) -LBB34_12: +LBB30_12: WORD $0xc789 // movl %eax, %edi LONG $0xc0f8e781; WORD $0xc0c0 // andl $-1061109512, %edi LONG $0x80f0ff81; WORD $0x8080 // cmpl $-2139062032, %edi - LONG $0x0026850f; WORD $0x0000 // jne LBB34_16, $38(%rip) + LONG $0x0026850f; WORD $0x0000 // jne LBB30_16, $38(%rip) WORD $0xc789 // movl %eax, %edi LONG $0x3007e781; WORD $0x0000 // andl $12295, %edi - LONG $0x0018840f; WORD $0x0000 // je LBB34_16, $24(%rip) + LONG $0x0018840f; WORD $0x0000 // je LBB30_16, $24(%rip) LONG $0x000004bb; BYTE $0x00 // movl $4, %ebx WORD $0x04a8 // testb $4, %al - LONG $0xff4d840f; WORD $0xffff // je LBB34_19, $-179(%rip) + LONG $0xff4d840f; WORD $0xffff // je LBB30_19, $-179(%rip) LONG $0x00300325; BYTE $0x00 // andl $12291, %eax - LONG $0xff42840f; WORD $0xffff // je LBB34_19, $-190(%rip) + LONG $0xff42840f; WORD $0xffff // je LBB30_19, $-190(%rip) -LBB34_16: +LBB30_16: WORD $0x8948; BYTE $0xcf // movq %rcx, %rdi WORD $0x294c; BYTE $0xd7 // subq %r10, %rdi WORD $0x8b48; BYTE $0x1a // movq (%rdx), %rbx LONG $0x00fb8148; WORD $0x0010; BYTE $0x00 // cmpq $4096, %rbx - LONG $0x0187830f; WORD $0x0000 // jae LBB34_17, $391(%rip) + LONG $0x0187830f; WORD $0x0000 // jae LBB30_17, $391(%rip) WORD $0x6348; BYTE $0xc7 // movslq %edi, %rax LONG $0x017b8d48 // leaq $1(%rbx), %rdi WORD $0x8948; BYTE $0x3a // movq %rdi, (%rdx) LONG $0xda448948; BYTE $0x08 // movq %rax, $8(%rdx,%rbx,8) LONG $0x000001bb; BYTE $0x00 // movl $1, %ebx - LONG $0xffff13e9; BYTE $0xff // jmp LBB34_19, $-237(%rip) + LONG $0xffff13e9; BYTE $0xff // jmp LBB30_19, $-237(%rip) -LBB34_2: +LBB30_2: WORD $0x014d; BYTE $0xd3 // addq %r10, %r11 WORD $0x394c; BYTE $0xd9 // cmpq %r11, %rcx - LONG $0x013e830f; WORD $0x0000 // jae LBB34_36, $318(%rip) + LONG $0x013e830f; WORD $0x0000 // jae LBB30_36, $318(%rip) LONG $0xdc458d4c // leaq $-36(%rbp), %r8 LONG $0xda4d8d4c // leaq $-38(%rbp), %r9 - LONG $0x000016e9; BYTE $0x00 // jmp LBB34_4, $22(%rip) + LONG $0x000016e9; BYTE $0x00 // jmp LBB30_4, $22(%rip) QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90 -LBB34_5: +LBB30_5: WORD $0xff48; BYTE $0xc1 // incq %rcx WORD $0x394c; BYTE $0xd9 // cmpq %r11, %rcx - LONG $0x011b830f; WORD $0x0000 // jae LBB34_36, $283(%rip) + LONG $0x011b830f; WORD $0x0000 // jae LBB30_36, $283(%rip) -LBB34_4: +LBB30_4: WORD $0x3980; BYTE $0x00 // cmpb $0, (%rcx) - LONG $0xffeb890f; WORD $0xffff // jns LBB34_5, $-21(%rip) + LONG $0xffeb890f; WORD $0xffff // jns LBB30_5, $-21(%rip) LONG $0x00dc45c6 // movb $0, $-36(%rbp) LONG $0x00da45c6 // movb $0, $-38(%rbp) WORD $0x894c; BYTE $0xdb // movq %r11, %rbx WORD $0x2948; BYTE $0xcb // subq %rcx, %rbx LONG $0x02fb8348 // cmpq $2, %rbx - LONG $0x0035820f; WORD $0x0000 // jb LBB34_21, $53(%rip) + LONG $0x0035820f; WORD $0x0000 // jb LBB30_21, $53(%rip) LONG $0x21b60f44 // movzbl (%rcx), %r12d LONG $0x71b60f44; BYTE $0x01 // movzbl $1(%rcx), %r14d LONG $0xdc658844 // movb %r12b, $-36(%rbp) @@ -9137,67 +8884,66 @@ LBB34_4: LONG $0xfec38348 // addq $-2, %rbx WORD $0x894c; BYTE $0xcf // movq %r9, %rdi WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx - LONG $0x0029840f; WORD $0x0000 // je LBB34_24, $41(%rip) + LONG $0x0029840f; WORD $0x0000 // je LBB30_24, $41(%rip) -LBB34_25: +LBB30_25: LONG $0x07b60f41 // movzbl (%r15), %eax WORD $0x0788 // movb %al, (%rdi) LONG $0x65b60f44; BYTE $0xdc // movzbl $-36(%rbp), %r12d LONG $0xda7db60f // movzbl $-38(%rbp), %edi - LONG $0x000017e9; BYTE $0x00 // jmp LBB34_26, $23(%rip) + LONG $0x000017e9; BYTE $0x00 // jmp LBB30_26, $23(%rip) -LBB34_21: +LBB30_21: WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d WORD $0x894c; BYTE $0xc7 // movq %r8, %rdi WORD $0x8949; BYTE $0xcf // movq %rcx, %r15 WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx - LONG $0xffd7850f; WORD $0xffff // jne LBB34_25, $-41(%rip) + LONG $0xffd7850f; WORD $0xffff // jne LBB30_25, $-41(%rip) -LBB34_24: +LBB30_24: WORD $0xff31 // xorl %edi, %edi -LBB34_26: +LBB30_26: LONG $0xc7b60f40 // movzbl %dil, %eax WORD $0xe0c1; BYTE $0x10 // shll $16, %eax LONG $0xdeb60f41 // movzbl %r14b, %ebx WORD $0xe3c1; BYTE $0x08 // shll $8, %ebx - WORD $0xc309 // orl %eax, %ebx LONG $0xfcb60f41 // movzbl %r12b, %edi WORD $0xdf09 // orl %ebx, %edi - WORD $0xf889 // movl %edi, %eax + WORD $0xf809 // orl %edi, %eax LONG $0xc0c0f025; BYTE $0x00 // andl $12632304, %eax LONG $0x8080e03d; BYTE $0x00 // cmpl $8421600, %eax - LONG $0x001f850f; WORD $0x0000 // jne LBB34_29, $31(%rip) + LONG $0x0021850f; WORD $0x0000 // jne LBB30_29, $33(%rip) WORD $0xf889 // movl %edi, %eax LONG $0x00200f25; BYTE $0x00 // andl $8207, %eax LONG $0x00200d3d; BYTE $0x00 // cmpl $8205, %eax - LONG $0x000d840f; WORD $0x0000 // je LBB34_29, $13(%rip) + LONG $0x000f840f; WORD $0x0000 // je LBB30_29, $15(%rip) LONG $0x000003bb; BYTE $0x00 // movl $3, %ebx WORD $0xc085 // testl %eax, %eax - LONG $0x0021850f; WORD $0x0000 // jne LBB34_34, $33(%rip) + LONG $0x0023850f; WORD $0x0000 // jne LBB30_34, $35(%rip) + WORD $0x9090 // .p2align 4, 0x90 - // .p2align 4, 0x90 -LBB34_29: +LBB30_29: LONG $0x1ec4f641 // testb $30, %r12b - LONG $0x0028840f; WORD $0x0000 // je LBB34_31, $40(%rip) + LONG $0x0028840f; WORD $0x0000 // je LBB30_31, $40(%rip) LONG $0xc0e0e781; WORD $0x0000 // andl $49376, %edi LONG $0x000002bb; BYTE $0x00 // movl $2, %ebx LONG $0x80c0ff81; WORD $0x0000 // cmpl $32960, %edi - LONG $0x0011850f; WORD $0x0000 // jne LBB34_31, $17(%rip) + LONG $0x0011850f; WORD $0x0000 // jne LBB30_31, $17(%rip) -LBB34_34: +LBB30_34: WORD $0x0148; BYTE $0xd9 // addq %rbx, %rcx WORD $0x394c; BYTE $0xd9 // cmpq %r11, %rcx - LONG $0xff1f820f; WORD $0xffff // jb LBB34_4, $-225(%rip) - LONG $0x000035e9; BYTE $0x00 // jmp LBB34_36, $53(%rip) + LONG $0xff1f820f; WORD $0xffff // jb LBB30_4, $-225(%rip) + LONG $0x000035e9; BYTE $0x00 // jmp LBB30_36, $53(%rip) -LBB34_31: +LBB30_31: WORD $0x8948; BYTE $0xc8 // movq %rcx, %rax WORD $0x294c; BYTE $0xd0 // subq %r10, %rax WORD $0x8b48; BYTE $0x3a // movq (%rdx), %rdi LONG $0x00ff8148; WORD $0x0010; BYTE $0x00 // cmpq $4096, %rdi - LONG $0x0034830f; WORD $0x0000 // jae LBB34_32, $52(%rip) + LONG $0x0034830f; WORD $0x0000 // jae LBB30_32, $52(%rip) WORD $0x9848 // cltq LONG $0x015f8d48 // leaq $1(%rdi), %rbx WORD $0x8948; BYTE $0x1a // movq %rbx, (%rdx) @@ -9205,14 +8951,14 @@ LBB34_31: LONG $0x000001bb; BYTE $0x00 // movl $1, %ebx WORD $0x0148; BYTE $0xd9 // addq %rbx, %rcx WORD $0x394c; BYTE $0xd9 // cmpq %r11, %rcx - LONG $0xfee5820f; WORD $0xffff // jb LBB34_4, $-283(%rip) + LONG $0xfee5820f; WORD $0xffff // jb LBB30_4, $-283(%rip) -LBB34_36: +LBB30_36: WORD $0x294c; BYTE $0xd1 // subq %r10, %rcx WORD $0x8948; BYTE $0x0e // movq %rcx, (%rsi) WORD $0xc031 // xorl %eax, %eax -LBB34_37: +LBB30_37: LONG $0x08c48348 // addq $8, %rsp BYTE $0x5b // popq %rbx WORD $0x5c41 // popq %r12 @@ -9221,22 +8967,22 @@ LBB34_37: BYTE $0x5d // popq %rbp BYTE $0xc3 // retq -LBB34_32: +LBB30_32: WORD $0x8948; BYTE $0x06 // movq %rax, (%rsi) LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax - LONG $0xffffe4e9; BYTE $0xff // jmp LBB34_37, $-28(%rip) + LONG $0xffffe4e9; BYTE $0xff // jmp LBB30_37, $-28(%rip) -LBB34_17: - WORD $0x8948; BYTE $0x3e // movq %rdi, (%rsi) - LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax - LONG $0xffffd5e9; BYTE $0xff // jmp LBB34_37, $-43(%rip) - LONG $0x00000000; WORD $0x0000 // .p2align 5, 0x00 +LBB30_17: + WORD $0x8948; BYTE $0x3e // movq %rdi, (%rsi) + LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax + LONG $0xffffd5e9; BYTE $0xff // jmp LBB30_37, $-43(%rip) + QUAD $0x0000000000000000; QUAD $0x0000000000000000; LONG $0x00000000; WORD $0x0000 // .p2align 5, 0x00 -LCPI35_0: +LCPI31_0: QUAD $0x0f0f0f0f0f0f0f0f; QUAD $0x0f0f0f0f0f0f0f0f // .space 16, '\x0f\x0f\x0f\x0f\x0f\x0f\x0f\x0f\x0f\x0f\x0f\x0f\x0f\x0f\x0f\x0f' QUAD $0x0f0f0f0f0f0f0f0f; QUAD $0x0f0f0f0f0f0f0f0f // .space 16, '\x0f\x0f\x0f\x0f\x0f\x0f\x0f\x0f\x0f\x0f\x0f\x0f\x0f\x0f\x0f\x0f' -LCPI35_1: +LCPI31_1: BYTE $0x02 // .byte 2 BYTE $0x02 // .byte 2 BYTE $0x02 // .byte 2 @@ -9270,7 +9016,7 @@ LCPI35_1: BYTE $0x15 // .byte 21 BYTE $0x49 // .byte 73 -LCPI35_2: +LCPI31_2: BYTE $0xe7 // .byte 231 BYTE $0xa3 // .byte 163 BYTE $0x83 // .byte 131 @@ -9304,7 +9050,7 @@ LCPI35_2: BYTE $0xcb // .byte 203 BYTE $0xcb // .byte 203 -LCPI35_3: +LCPI31_3: BYTE $0x01 // .byte 1 BYTE $0x01 // .byte 1 BYTE $0x01 // .byte 1 @@ -9338,15 +9084,15 @@ LCPI35_3: BYTE $0x01 // .byte 1 BYTE $0x01 // .byte 1 -LCPI35_4: +LCPI31_4: QUAD $0xdfdfdfdfdfdfdfdf; QUAD $0xdfdfdfdfdfdfdfdf // .space 16, '\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf' QUAD $0xdfdfdfdfdfdfdfdf; QUAD $0xdfdfdfdfdfdfdfdf // .space 16, '\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf' -LCPI35_5: +LCPI31_5: QUAD $0xefefefefefefefef; QUAD $0xefefefefefefefef // .space 16, '\xef\xef\xef\xef\xef\xef\xef\xef\xef\xef\xef\xef\xef\xef\xef\xef' QUAD $0xefefefefefefefef; QUAD $0xefefefefefefefef // .space 16, '\xef\xef\xef\xef\xef\xef\xef\xef\xef\xef\xef\xef\xef\xef\xef\xef' -LCPI35_7: +LCPI31_7: BYTE $0xff // .byte 255 BYTE $0xff // .byte 255 BYTE $0xff // .byte 255 @@ -9380,74 +9126,75 @@ LCPI35_7: BYTE $0xdf // .byte 223 BYTE $0xbf // .byte 191 -LCPI35_8: +LCPI31_8: QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' // .p2align 3, 0x00 -LCPI35_6: +LCPI31_6: QUAD $0x8080808080808080 // .quad -9187201950435737472 QUAD $0x9090909090909090 // .p2align 4, 0x90 _validate_utf8_fast: - BYTE $0x55 // pushq %rbp - WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp - BYTE $0x53 // pushq %rbx - LONG $0xe0e48348 // andq $-32, %rsp - LONG $0xa0ec8148; WORD $0x0000; BYTE $0x00 // subq $160, %rsp - LONG $0x08578b4c // movq $8(%rdi), %r10 - WORD $0x854d; BYTE $0xd2 // testq %r10, %r10 - LONG $0x0910840f; WORD $0x0000 // je LBB35_22, $2320(%rip) - WORD $0x8b4c; BYTE $0x0f // movq (%rdi), %r9 - WORD $0x014d; BYTE $0xca // addq %r9, %r10 - LONG $0x80728d49 // leaq $-128(%r10), %rsi - LONG $0xc9eff1c5 // vpxor %xmm1, %xmm1, %xmm1 - LONG $0xd2efe9c5 // vpxor %xmm2, %xmm2, %xmm2 - LONG $0xc0eff9c5 // vpxor %xmm0, %xmm0, %xmm0 - WORD $0x894c; BYTE $0xc8 // movq %r9, %rax - WORD $0x394c; BYTE $0xce // cmpq %r9, %rsi - LONG $0x0366860f; WORD $0x0000 // jbe LBB35_12, $870(%rip) - QUAD $0xfffffea9256ffdc5 // vmovdqa $-343(%rip), %ymm4 /* LCPI35_0(%rip) */ - QUAD $0xfffffee1356ffdc5 // vmovdqa $-287(%rip), %ymm6 /* LCPI35_2(%rip) */ - QUAD $0xfffffef93d6ffdc5 // vmovdqa $-263(%rip), %ymm7 /* LCPI35_3(%rip) */ - QUAD $0xffffff11056f7dc5 // vmovdqa $-239(%rip), %ymm8 /* LCPI35_4(%rip) */ - QUAD $0xffffff290d6f7dc5 // vmovdqa $-215(%rip), %ymm9 /* LCPI35_5(%rip) */ - QUAD $0xffffff41156f7dc5 // vmovdqa $-191(%rip), %ymm10 /* LCPI35_7(%rip) */ - WORD $0x894c; BYTE $0xc8 // movq %r9, %rax - LONG $0xc0eff9c5 // vpxor %xmm0, %xmm0, %xmm0 - LONG $0xd2efe9c5 // vpxor %xmm2, %xmm2, %xmm2 - LONG $0xc9eff1c5 // vpxor %xmm1, %xmm1, %xmm1 - WORD $0x9090 // .p2align 4, 0x90 + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5641 // pushq %r14 + BYTE $0x53 // pushq %rbx + LONG $0xe0e48348 // andq $-32, %rsp + LONG $0x80ec8148; WORD $0x0000; BYTE $0x00 // subq $128, %rsp + LONG $0x08478b48 // movq $8(%rdi), %rax + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0x079d840f; WORD $0x0000 // je LBB31_69, $1949(%rip) + WORD $0x8b4c; BYTE $0x07 // movq (%rdi), %r8 + LONG $0x00348d4d // leaq (%r8,%rax), %r14 + LONG $0x807e8d49 // leaq $-128(%r14), %rdi + LONG $0xc9eff1c5 // vpxor %xmm1, %xmm1, %xmm1 + LONG $0xd2efe9c5 // vpxor %xmm2, %xmm2, %xmm2 + LONG $0xc0eff9c5 // vpxor %xmm0, %xmm0, %xmm0 + WORD $0x894c; BYTE $0xc6 // movq %r8, %rsi + WORD $0x394c; BYTE $0xc7 // cmpq %r8, %rdi + LONG $0x0373860f; WORD $0x0000 // jbe LBB31_12, $883(%rip) + QUAD $0xfffffea6256ffdc5 // vmovdqa $-346(%rip), %ymm4 /* LCPI31_0(%rip) */ + QUAD $0xfffffede356ffdc5 // vmovdqa $-290(%rip), %ymm6 /* LCPI31_2(%rip) */ + QUAD $0xfffffef63d6ffdc5 // vmovdqa $-266(%rip), %ymm7 /* LCPI31_3(%rip) */ + QUAD $0xffffff0e056f7dc5 // vmovdqa $-242(%rip), %ymm8 /* LCPI31_4(%rip) */ + QUAD $0xffffff260d6f7dc5 // vmovdqa $-218(%rip), %ymm9 /* LCPI31_5(%rip) */ + QUAD $0xffffff3e156f7dc5 // vmovdqa $-194(%rip), %ymm10 /* LCPI31_7(%rip) */ + WORD $0x894c; BYTE $0xc6 // movq %r8, %rsi + LONG $0xc0eff9c5 // vpxor %xmm0, %xmm0, %xmm0 + LONG $0xd2efe9c5 // vpxor %xmm2, %xmm2, %xmm2 + LONG $0xc9eff1c5 // vpxor %xmm1, %xmm1, %xmm1 + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 -LBB35_3: - LONG $0x386f7ec5 // vmovdqu (%rax), %ymm15 - LONG $0x686f7ec5; BYTE $0x20 // vmovdqu $32(%rax), %ymm13 - LONG $0x606f7ec5; BYTE $0x40 // vmovdqu $64(%rax), %ymm12 - LONG $0x586f7ec5; BYTE $0x60 // vmovdqu $96(%rax), %ymm11 +LBB31_3: + LONG $0x3e6f7ec5 // vmovdqu (%rsi), %ymm15 + LONG $0x6e6f7ec5; BYTE $0x20 // vmovdqu $32(%rsi), %ymm13 + LONG $0x666f7ec5; BYTE $0x40 // vmovdqu $64(%rsi), %ymm12 + LONG $0x5e6f7ec5; BYTE $0x60 // vmovdqu $96(%rsi), %ymm11 LONG $0xeb15c1c4; BYTE $0xdf // vpor %ymm15, %ymm13, %ymm3 LONG $0xeb2541c4; BYTE $0xf4 // vpor %ymm12, %ymm11, %ymm14 LONG $0xebeb8dc5 // vpor %ymm3, %ymm14, %ymm5 LONG $0xcdd7fdc5 // vpmovmskb %ymm5, %ecx WORD $0xc985 // testl %ecx, %ecx - LONG $0x0016850f; WORD $0x0000 // jne LBB35_6, $22(%rip) + LONG $0x0016850f; WORD $0x0000 // jne LBB31_6, $22(%rip) LONG $0xc0ebf5c5 // vpor %ymm0, %ymm1, %ymm0 -LBB35_5: - LONG $0x80e88348 // subq $-128, %rax - WORD $0x3948; BYTE $0xf0 // cmpq %rsi, %rax - LONG $0xffc2820f; WORD $0xffff // jb LBB35_3, $-62(%rip) - LONG $0x0002e2e9; BYTE $0x00 // jmp LBB35_12, $738(%rip) +LBB31_5: + LONG $0x80ee8348 // subq $-128, %rsi + WORD $0x3948; BYTE $0xfe // cmpq %rdi, %rsi + LONG $0xffc2820f; WORD $0xffff // jb LBB31_3, $-62(%rip) + LONG $0x0002e2e9; BYTE $0x00 // jmp LBB31_12, $738(%rip) -LBB35_6: +LBB31_6: LONG $0xcbd7fdc5 // vpmovmskb %ymm3, %ecx WORD $0xc985 // testl %ecx, %ecx - LONG $0x00f0850f; WORD $0x0000 // jne LBB35_9, $240(%rip) + LONG $0x00f0850f; WORD $0x0000 // jne LBB31_9, $240(%rip) LONG $0xc0ebf5c5 // vpor %ymm0, %ymm1, %ymm0 LONG $0x466dc3c4; WORD $0x21cc // vperm2i128 $33, %ymm12, %ymm2, %ymm1 LONG $0x0f1de3c4; WORD $0x0fd1 // vpalignr $15, %ymm1, %ymm12, %ymm2 LONG $0xd271e5c5; BYTE $0x04 // vpsrlw $4, %ymm2, %ymm3 LONG $0xdcdbe5c5 // vpand %ymm4, %ymm3, %ymm3 - QUAD $0xfffffe20356f7dc5 // vmovdqa $-480(%rip), %ymm14 /* LCPI35_1(%rip) */ + QUAD $0xfffffe10356f7dc5 // vmovdqa $-496(%rip), %ymm14 /* LCPI31_1(%rip) */ LONG $0x000de2c4; BYTE $0xdb // vpshufb %ymm3, %ymm14, %ymm3 LONG $0xd4dbedc5 // vpand %ymm4, %ymm2, %ymm2 LONG $0x004de2c4; BYTE $0xd2 // vpshufb %ymm2, %ymm6, %ymm2 @@ -9463,7 +9210,7 @@ LBB35_6: LONG $0xcbebf5c5 // vpor %ymm3, %ymm1, %ymm1 LONG $0xef1141c4; BYTE $0xed // vpxor %xmm13, %xmm13, %xmm13 LONG $0xc97495c5 // vpcmpeqb %ymm1, %ymm13, %ymm1 - QUAD $0xfffeaf1d597de2c4; BYTE $0xff // vpbroadcastq $-337(%rip), %ymm3 /* LCPI35_6(%rip) */ + QUAD $0xfffe9f1d597de2c4; BYTE $0xff // vpbroadcastq $-353(%rip), %ymm3 /* LCPI31_6(%rip) */ LONG $0xcbdff5c5 // vpandn %ymm3, %ymm1, %ymm1 LONG $0xcaeff5c5 // vpxor %ymm2, %ymm1, %ymm1 LONG $0xc1ebfdc5 // vpor %ymm1, %ymm0, %ymm0 @@ -9488,18 +9235,18 @@ LBB35_6: LONG $0xcbdff5c5 // vpandn %ymm3, %ymm1, %ymm1 LONG $0xcaeff5c5 // vpxor %ymm2, %ymm1, %ymm1 -LBB35_8: +LBB31_8: LONG $0xc1ebfdc5 // vpor %ymm1, %ymm0, %ymm0 LONG $0xd825c1c4; BYTE $0xca // vpsubusb %ymm10, %ymm11, %ymm1 LONG $0xda7f7dc5 // vmovdqa %ymm11, %ymm2 - LONG $0xfffef2e9; BYTE $0xff // jmp LBB35_5, $-270(%rip) + LONG $0xfffef2e9; BYTE $0xff // jmp LBB31_5, $-270(%rip) -LBB35_9: +LBB31_9: LONG $0x466dc3c4; WORD $0x21cf // vperm2i128 $33, %ymm15, %ymm2, %ymm1 LONG $0x0f05e3c4; WORD $0x0fd1 // vpalignr $15, %ymm1, %ymm15, %ymm2 LONG $0xd271e5c5; BYTE $0x04 // vpsrlw $4, %ymm2, %ymm3 LONG $0xdcdbe5c5 // vpand %ymm4, %ymm3, %ymm3 - QUAD $0xfffffd342d6ffdc5 // vmovdqa $-716(%rip), %ymm5 /* LCPI35_1(%rip) */ + QUAD $0xfffffd242d6ffdc5 // vmovdqa $-732(%rip), %ymm5 /* LCPI31_1(%rip) */ LONG $0x0055e2c4; BYTE $0xdb // vpshufb %ymm3, %ymm5, %ymm3 LONG $0xd4dbedc5 // vpand %ymm4, %ymm2, %ymm2 LONG $0x004de2c4; BYTE $0xd2 // vpshufb %ymm2, %ymm6, %ymm2 @@ -9515,7 +9262,7 @@ LBB35_9: LONG $0xcbebf5c5 // vpor %ymm3, %ymm1, %ymm1 LONG $0xdbefe1c5 // vpxor %xmm3, %xmm3, %xmm3 LONG $0xdb74f5c5 // vpcmpeqb %ymm3, %ymm1, %ymm3 - QUAD $0xfffdc40d597de2c4; BYTE $0xff // vpbroadcastq $-572(%rip), %ymm1 /* LCPI35_6(%rip) */ + QUAD $0xfffdb40d597de2c4; BYTE $0xff // vpbroadcastq $-588(%rip), %ymm1 /* LCPI31_6(%rip) */ LONG $0xd9dfe5c5 // vpandn %ymm1, %ymm3, %ymm3 LONG $0xd2efe5c5 // vpxor %ymm2, %ymm3, %ymm2 LONG $0x547ffdc5; WORD $0x6024 // vmovdqa %ymm2, $96(%rsp) @@ -9523,7 +9270,7 @@ LBB35_9: LONG $0x0f15e3c4; WORD $0x0feb // vpalignr $15, %ymm3, %ymm13, %ymm5 LONG $0xd57185c5; BYTE $0x04 // vpsrlw $4, %ymm5, %ymm15 LONG $0xfcdb05c5 // vpand %ymm4, %ymm15, %ymm15 - QUAD $0xfffffcb9156ffdc5 // vmovdqa $-839(%rip), %ymm2 /* LCPI35_1(%rip) */ + QUAD $0xfffffca9156ffdc5 // vmovdqa $-855(%rip), %ymm2 /* LCPI31_1(%rip) */ LONG $0x006d42c4; BYTE $0xff // vpshufb %ymm15, %ymm2, %ymm15 LONG $0xecdbd5c5 // vpand %ymm4, %ymm5, %ymm5 LONG $0x004de2c4; BYTE $0xed // vpshufb %ymm5, %ymm6, %ymm5 @@ -9537,19 +9284,19 @@ LBB35_9: LONG $0xd855c1c4; BYTE $0xe8 // vpsubusb %ymm8, %ymm5, %ymm5 LONG $0xd865c1c4; BYTE $0xd9 // vpsubusb %ymm9, %ymm3, %ymm3 LONG $0xddebe5c5 // vpor %ymm5, %ymm3, %ymm3 - QUAD $0xfffffd321d74e5c5 // vpcmpeqb $-718(%rip), %ymm3, %ymm3 /* LCPI35_8(%rip) */ + QUAD $0xfffffd221d74e5c5 // vpcmpeqb $-734(%rip), %ymm3, %ymm3 /* LCPI31_8(%rip) */ LONG $0xd9dfe5c5 // vpandn %ymm1, %ymm3, %ymm3 LONG $0xd2efe5c5 // vpxor %ymm2, %ymm3, %ymm2 LONG $0x44ebfdc5; WORD $0x6024 // vpor $96(%rsp), %ymm0, %ymm0 LONG $0xc2ebfdc5 // vpor %ymm2, %ymm0, %ymm0 LONG $0xd77dc1c4; BYTE $0xce // vpmovmskb %ymm14, %ecx WORD $0xc985 // testl %ecx, %ecx - LONG $0x00d6840f; WORD $0x0000 // je LBB35_11, $214(%rip) + LONG $0x00d6840f; WORD $0x0000 // je LBB31_11, $214(%rip) LONG $0x4615c3c4; WORD $0x21d4 // vperm2i128 $33, %ymm12, %ymm13, %ymm2 LONG $0x0f1de3c4; WORD $0x0fda // vpalignr $15, %ymm2, %ymm12, %ymm3 LONG $0xd371d5c5; BYTE $0x04 // vpsrlw $4, %ymm3, %ymm5 LONG $0xecdbd5c5 // vpand %ymm4, %ymm5, %ymm5 - QUAD $0xfffffc363d6f7dc5 // vmovdqa $-970(%rip), %ymm15 /* LCPI35_1(%rip) */ + QUAD $0xfffffc263d6f7dc5 // vmovdqa $-986(%rip), %ymm15 /* LCPI31_1(%rip) */ LONG $0x0005e2c4; BYTE $0xed // vpshufb %ymm5, %ymm15, %ymm5 LONG $0xdcdbe5c5 // vpand %ymm4, %ymm3, %ymm3 LONG $0x004de2c4; BYTE $0xdb // vpshufb %ymm3, %ymm6, %ymm3 @@ -9588,42 +9335,42 @@ LBB35_9: LONG $0xc9dfe5c5 // vpandn %ymm1, %ymm3, %ymm1 LONG $0xcdeff5c5 // vpxor %ymm5, %ymm1, %ymm1 LONG $0xc0ebedc5 // vpor %ymm0, %ymm2, %ymm0 - LONG $0xfffe1ae9; BYTE $0xff // jmp LBB35_8, $-486(%rip) + LONG $0xfffe1ae9; BYTE $0xff // jmp LBB31_8, $-486(%rip) -LBB35_11: +LBB31_11: LONG $0xd815c1c4; BYTE $0xca // vpsubusb %ymm10, %ymm13, %ymm1 LONG $0xc1ebfdc5 // vpor %ymm1, %ymm0, %ymm0 LONG $0xea7f7dc5 // vmovdqa %ymm13, %ymm2 - LONG $0xfffd0ce9; BYTE $0xff // jmp LBB35_5, $-756(%rip) - -LBB35_12: - LONG $0xc0728d49 // leaq $-64(%r10), %rsi - WORD $0x3948; BYTE $0xf0 // cmpq %rsi, %rax - LONG $0x0159830f; WORD $0x0000 // jae LBB35_17, $345(%rip) - QUAD $0xfffffb361d6ffdc5 // vmovdqa $-1226(%rip), %ymm3 /* LCPI35_0(%rip) */ - QUAD $0xfffffb4e256ffdc5 // vmovdqa $-1202(%rip), %ymm4 /* LCPI35_1(%rip) */ - QUAD $0xfffffb662d6ffdc5 // vmovdqa $-1178(%rip), %ymm5 /* LCPI35_2(%rip) */ - QUAD $0xfffffb7e356ffdc5 // vmovdqa $-1154(%rip), %ymm6 /* LCPI35_3(%rip) */ - QUAD $0xfffffb963d6ffdc5 // vmovdqa $-1130(%rip), %ymm7 /* LCPI35_4(%rip) */ - QUAD $0xfffffbae056f7dc5 // vmovdqa $-1106(%rip), %ymm8 /* LCPI35_5(%rip) */ + LONG $0xfffd0ce9; BYTE $0xff // jmp LBB31_5, $-756(%rip) + +LBB31_12: + LONG $0xc07e8d49 // leaq $-64(%r14), %rdi + WORD $0x3948; BYTE $0xfe // cmpq %rdi, %rsi + LONG $0x0159830f; WORD $0x0000 // jae LBB31_17, $345(%rip) + QUAD $0xfffffb261d6ffdc5 // vmovdqa $-1242(%rip), %ymm3 /* LCPI31_0(%rip) */ + QUAD $0xfffffb3e256ffdc5 // vmovdqa $-1218(%rip), %ymm4 /* LCPI31_1(%rip) */ + QUAD $0xfffffb562d6ffdc5 // vmovdqa $-1194(%rip), %ymm5 /* LCPI31_2(%rip) */ + QUAD $0xfffffb6e356ffdc5 // vmovdqa $-1170(%rip), %ymm6 /* LCPI31_3(%rip) */ + QUAD $0xfffffb863d6ffdc5 // vmovdqa $-1146(%rip), %ymm7 /* LCPI31_4(%rip) */ + QUAD $0xfffffb9e056f7dc5 // vmovdqa $-1122(%rip), %ymm8 /* LCPI31_5(%rip) */ LONG $0xef3141c4; BYTE $0xc9 // vpxor %xmm9, %xmm9, %xmm9 - QUAD $0xfffffbc1156f7dc5 // vmovdqa $-1087(%rip), %ymm10 /* LCPI35_7(%rip) */ + QUAD $0xfffffbb1156f7dc5 // vmovdqa $-1103(%rip), %ymm10 /* LCPI31_7(%rip) */ BYTE $0x90 // .p2align 4, 0x90 -LBB35_14: - LONG $0x206f7ec5 // vmovdqu (%rax), %ymm12 - LONG $0x586f7ec5; BYTE $0x20 // vmovdqu $32(%rax), %ymm11 +LBB31_14: + LONG $0x266f7ec5 // vmovdqu (%rsi), %ymm12 + LONG $0x5e6f7ec5; BYTE $0x20 // vmovdqu $32(%rsi), %ymm11 LONG $0xeb2541c4; BYTE $0xec // vpor %ymm12, %ymm11, %ymm13 LONG $0xd77dc1c4; BYTE $0xcd // vpmovmskb %ymm13, %ecx WORD $0xc985 // testl %ecx, %ecx - LONG $0x0016850f; WORD $0x0000 // jne LBB35_16, $22(%rip) + LONG $0x0016850f; WORD $0x0000 // jne LBB31_16, $22(%rip) LONG $0xc0ebf5c5 // vpor %ymm0, %ymm1, %ymm0 - LONG $0x40c08348 // addq $64, %rax - WORD $0x3948; BYTE $0xf0 // cmpq %rsi, %rax - LONG $0xffd4820f; WORD $0xffff // jb LBB35_14, $-44(%rip) - LONG $0x0000eae9; BYTE $0x00 // jmp LBB35_17, $234(%rip) + LONG $0x40c68348 // addq $64, %rsi + WORD $0x3948; BYTE $0xfe // cmpq %rdi, %rsi + LONG $0xffd4820f; WORD $0xffff // jb LBB31_14, $-44(%rip) + LONG $0x0000eae9; BYTE $0x00 // jmp LBB31_17, $234(%rip) -LBB35_16: +LBB31_16: LONG $0x466dc3c4; WORD $0x21cc // vperm2i128 $33, %ymm12, %ymm2, %ymm1 LONG $0x0f1de3c4; WORD $0x0fd1 // vpalignr $15, %ymm1, %ymm12, %ymm2 LONG $0xd27195c5; BYTE $0x04 // vpsrlw $4, %ymm2, %ymm13 @@ -9642,7 +9389,7 @@ LBB35_16: LONG $0xd875c1c4; BYTE $0xc8 // vpsubusb %ymm8, %ymm1, %ymm1 LONG $0xc9eb95c5 // vpor %ymm1, %ymm13, %ymm1 LONG $0xc974b5c5 // vpcmpeqb %ymm1, %ymm9, %ymm1 - QUAD $0xfffb6f2d597d62c4; BYTE $0xff // vpbroadcastq $-1169(%rip), %ymm13 /* LCPI35_6(%rip) */ + QUAD $0xfffb5f2d597d62c4; BYTE $0xff // vpbroadcastq $-1185(%rip), %ymm13 /* LCPI31_6(%rip) */ LONG $0xdf75c1c4; BYTE $0xcd // vpandn %ymm13, %ymm1, %ymm1 LONG $0xcaeff5c5 // vpxor %ymm2, %ymm1, %ymm1 LONG $0x461dc3c4; WORD $0x21d3 // vperm2i128 $33, %ymm11, %ymm12, %ymm2 @@ -9669,365 +9416,335 @@ LBB35_16: LONG $0xc2ebfdc5 // vpor %ymm2, %ymm0, %ymm0 LONG $0xd825c1c4; BYTE $0xca // vpsubusb %ymm10, %ymm11, %ymm1 LONG $0xda7f7dc5 // vmovdqa %ymm11, %ymm2 - LONG $0x40c08348 // addq $64, %rax - WORD $0x3948; BYTE $0xf0 // cmpq %rsi, %rax - LONG $0xfee5820f; WORD $0xffff // jb LBB35_14, $-283(%rip) + LONG $0x40c68348 // addq $64, %rsi + WORD $0x3948; BYTE $0xfe // cmpq %rdi, %rsi + LONG $0xfee5820f; WORD $0xffff // jb LBB31_14, $-283(%rip) -LBB35_17: +LBB31_17: LONG $0xdbefe1c5 // vpxor %xmm3, %xmm3, %xmm3 LONG $0x5c7ffdc5; WORD $0x4024 // vmovdqa %ymm3, $64(%rsp) LONG $0x5c7ffdc5; WORD $0x2024 // vmovdqa %ymm3, $32(%rsp) LONG $0xe4efd9c5 // vpxor %xmm4, %xmm4, %xmm4 - WORD $0x394c; BYTE $0xd0 // cmpq %r10, %rax - LONG $0x01d7830f; WORD $0x0000 // jae LBB35_39, $471(%rip) - WORD $0x894c; BYTE $0xd7 // movq %r10, %rdi - WORD $0x2948; BYTE $0xc7 // subq %rax, %rdi - WORD $0xf631 // xorl %esi, %esi - LONG $0x10ff8348 // cmpq $16, %rdi - LONG $0x002c820f; WORD $0x0000 // jb LBB35_23, $44(%rip) - LONG $0x24548d48; BYTE $0x20 // leaq $32(%rsp), %rdx - WORD $0x2948; BYTE $0xc2 // subq %rax, %rdx + WORD $0x394c; BYTE $0xf6 // cmpq %r14, %rsi + LONG $0x0067830f; WORD $0x0000 // jae LBB31_34, $103(%rip) WORD $0x8948; BYTE $0xc1 // movq %rax, %rcx - LONG $0x80fa8148; WORD $0x0000; BYTE $0x00 // cmpq $128, %rdx - LONG $0x0179820f; WORD $0x0000 // jb LBB35_36, $377(%rip) - LONG $0x80ff8148; WORD $0x0000; BYTE $0x00 // cmpq $128, %rdi - LONG $0x000f830f; WORD $0x0000 // jae LBB35_24, $15(%rip) - WORD $0xf631 // xorl %esi, %esi - LONG $0x000114e9; BYTE $0x00 // jmp LBB35_31, $276(%rip) - -LBB35_23: - WORD $0x8948; BYTE $0xc1 // movq %rax, %rcx - LONG $0x00015de9; BYTE $0x00 // jmp LBB35_36, $349(%rip) - -LBB35_24: - WORD $0x8948; BYTE $0xfe // movq %rdi, %rsi - LONG $0x80e68348 // andq $-128, %rsi - LONG $0x804e8d48 // leaq $-128(%rsi), %rcx - WORD $0x8949; BYTE $0xc8 // movq %rcx, %r8 - LONG $0x07e8c149 // shrq $7, %r8 - WORD $0xff49; BYTE $0xc0 // incq %r8 - WORD $0x8548; BYTE $0xc9 // testq %rcx, %rcx - LONG $0x012a840f; WORD $0x0000 // je LBB35_34, $298(%rip) - WORD $0x894c; BYTE $0xc2 // movq %r8, %rdx - LONG $0xfee28348 // andq $-2, %rdx - WORD $0xc931 // xorl %ecx, %ecx - QUAD $0x9090909090909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 - -LBB35_26: - LONG $0x1c10fcc5; BYTE $0x08 // vmovups (%rax,%rcx), %ymm3 - LONG $0x6410fcc5; WORD $0x2008 // vmovups $32(%rax,%rcx), %ymm4 - LONG $0x6c10fcc5; WORD $0x4008 // vmovups $64(%rax,%rcx), %ymm5 - LONG $0x7410fcc5; WORD $0x6008 // vmovups $96(%rax,%rcx), %ymm6 - LONG $0x5c11fcc5; WORD $0x200c // vmovups %ymm3, $32(%rsp,%rcx) - LONG $0x6411fcc5; WORD $0x400c // vmovups %ymm4, $64(%rsp,%rcx) - LONG $0x6c11fcc5; WORD $0x600c // vmovups %ymm5, $96(%rsp,%rcx) - QUAD $0x0000800cb411fcc5; BYTE $0x00 // vmovups %ymm6, $128(%rsp,%rcx) - QUAD $0x000080089c6ffec5; BYTE $0x00 // vmovdqu $128(%rax,%rcx), %ymm3 - QUAD $0x0000a008a46ffec5; BYTE $0x00 // vmovdqu $160(%rax,%rcx), %ymm4 - QUAD $0x0000c008ac6ffec5; BYTE $0x00 // vmovdqu $192(%rax,%rcx), %ymm5 - QUAD $0x0000e008b46ffec5; BYTE $0x00 // vmovdqu $224(%rax,%rcx), %ymm6 - QUAD $0x0000a00c9c7ffec5; BYTE $0x00 // vmovdqu %ymm3, $160(%rsp,%rcx) - QUAD $0x0000c00ca47ffec5; BYTE $0x00 // vmovdqu %ymm4, $192(%rsp,%rcx) - QUAD $0x0000e00cac7ffec5; BYTE $0x00 // vmovdqu %ymm5, $224(%rsp,%rcx) - QUAD $0x0001000cb47ffec5; BYTE $0x00 // vmovdqu %ymm6, $256(%rsp,%rcx) - LONG $0x00c18148; WORD $0x0001; BYTE $0x00 // addq $256, %rcx - LONG $0xfec28348 // addq $-2, %rdx - LONG $0xff75850f; WORD $0xffff // jne LBB35_26, $-139(%rip) - LONG $0x01c0f641 // testb $1, %r8b - LONG $0x0032840f; WORD $0x0000 // je LBB35_29, $50(%rip) - -LBB35_28: - LONG $0x1c6ffec5; BYTE $0x08 // vmovdqu (%rax,%rcx), %ymm3 - LONG $0x646ffec5; WORD $0x2008 // vmovdqu $32(%rax,%rcx), %ymm4 - LONG $0x6c6ffec5; WORD $0x4008 // vmovdqu $64(%rax,%rcx), %ymm5 - LONG $0x746ffec5; WORD $0x6008 // vmovdqu $96(%rax,%rcx), %ymm6 - LONG $0x5c7ffec5; WORD $0x200c // vmovdqu %ymm3, $32(%rsp,%rcx) - LONG $0x647ffec5; WORD $0x400c // vmovdqu %ymm4, $64(%rsp,%rcx) - LONG $0x6c7ffec5; WORD $0x600c // vmovdqu %ymm5, $96(%rsp,%rcx) - QUAD $0x0000800cb47ffec5; BYTE $0x00 // vmovdqu %ymm6, $128(%rsp,%rcx) - -LBB35_29: - WORD $0x3948; BYTE $0xf7 // cmpq %rsi, %rdi - LONG $0x0083840f; WORD $0x0000 // je LBB35_38, $131(%rip) - LONG $0x70c7f640 // testb $112, %dil - LONG $0x004d840f; WORD $0x0000 // je LBB35_35, $77(%rip) - -LBB35_31: - WORD $0x8948; BYTE $0xf2 // movq %rsi, %rdx - WORD $0x8948; BYTE $0xfe // movq %rdi, %rsi - LONG $0xf0e68348 // andq $-16, %rsi - LONG $0x300c8d48 // leaq (%rax,%rsi), %rcx - QUAD $0x9090909090909090 // .p2align 4, 0x90 - -LBB35_32: - LONG $0x1c6ffac5; BYTE $0x10 // vmovdqu (%rax,%rdx), %xmm3 - LONG $0x5c7ff9c5; WORD $0x2014 // vmovdqa %xmm3, $32(%rsp,%rdx) - LONG $0x10c28348 // addq $16, %rdx - WORD $0x3948; BYTE $0xd6 // cmpq %rdx, %rsi - LONG $0xffe8850f; WORD $0xffff // jne LBB35_32, $-24(%rip) - WORD $0x3948; BYTE $0xf7 // cmpq %rsi, %rdi - LONG $0x001a850f; WORD $0x0000 // jne LBB35_36, $26(%rip) - LONG $0x00003de9; BYTE $0x00 // jmp LBB35_38, $61(%rip) - -LBB35_34: - WORD $0xc931 // xorl %ecx, %ecx - LONG $0x01c0f641 // testb $1, %r8b - LONG $0xff73850f; WORD $0xffff // jne LBB35_28, $-141(%rip) - LONG $0xffffa0e9; BYTE $0xff // jmp LBB35_29, $-96(%rip) - -LBB35_35: - LONG $0x300c8d48 // leaq (%rax,%rsi), %rcx + WORD $0x2948; BYTE $0xf1 // subq %rsi, %rcx + LONG $0x08148d4d // leaq (%r8,%rcx), %r10 + LONG $0x80fa8149; WORD $0x0000; BYTE $0x00 // cmpq $128, %r10 + LONG $0x001f820f; WORD $0x0000 // jb LBB31_19, $31(%rip) + LONG $0x24548d48; BYTE $0x20 // leaq $32(%rsp), %rdx + WORD $0x394c; BYTE $0xf2 // cmpq %r14, %rdx + LONG $0x026d830f; WORD $0x0000 // jae LBB31_24, $621(%rip) + LONG $0x0c4c8d48; BYTE $0x20 // leaq $32(%rsp,%rcx), %rcx + WORD $0x014c; BYTE $0xc1 // addq %r8, %rcx + WORD $0x3948; BYTE $0xce // cmpq %rcx, %rsi + LONG $0x025c830f; WORD $0x0000 // jae LBB31_24, $604(%rip) + +LBB31_19: + WORD $0x3145; BYTE $0xdb // xorl %r11d, %r11d -LBB35_36: - LONG $0x34148d48 // leaq (%rsp,%rsi), %rdx - LONG $0x20c28348 // addq $32, %rdx - WORD $0x894c; BYTE $0xd7 // movq %r10, %rdi - WORD $0x2948; BYTE $0xf7 // subq %rsi, %rdi - WORD $0x2948; BYTE $0xc7 // subq %rax, %rdi - WORD $0xc031 // xorl %eax, %eax - WORD $0x9090 // .p2align 4, 0x90 +LBB31_31: + LONG $0x1c4c8d4a; BYTE $0x20 // leaq $32(%rsp,%r11), %rcx + WORD $0x2948; BYTE $0xf0 // subq %rsi, %rax + WORD $0x014c; BYTE $0xc0 // addq %r8, %rax + WORD $0xd231 // xorl %edx, %edx + WORD $0x9090 // .p2align 4, 0x90 -LBB35_37: - LONG $0x011cb60f // movzbl (%rcx,%rax), %ebx - WORD $0x1c88; BYTE $0x02 // movb %bl, (%rdx,%rax) - WORD $0xff48; BYTE $0xc0 // incq %rax - WORD $0x3948; BYTE $0xc7 // cmpq %rax, %rdi - LONG $0xffed850f; WORD $0xffff // jne LBB35_37, $-19(%rip) +LBB31_32: + LONG $0x161cb60f // movzbl (%rsi,%rdx), %ebx + WORD $0x1c88; BYTE $0x11 // movb %bl, (%rcx,%rdx) + WORD $0xff48; BYTE $0xc2 // incq %rdx + WORD $0x3948; BYTE $0xd0 // cmpq %rdx, %rax + LONG $0xffed850f; WORD $0xffff // jne LBB31_32, $-19(%rip) -LBB35_38: +LBB31_33: LONG $0x646ffdc5; WORD $0x2024 // vmovdqa $32(%rsp), %ymm4 LONG $0x5c6ffdc5; WORD $0x4024 // vmovdqa $64(%rsp), %ymm3 -LBB35_39: +LBB31_34: LONG $0xebebddc5 // vpor %ymm3, %ymm4, %ymm5 LONG $0xc5d7fdc5 // vpmovmskb %ymm5, %eax WORD $0xc085 // testl %eax, %eax - LONG $0x022a850f; WORD $0x0000 // jne LBB35_42, $554(%rip) + LONG $0x033a850f; WORD $0x0000 // jne LBB31_38, $826(%rip) LONG $0xc1ebfdc5 // vpor %ymm1, %ymm0, %ymm0 LONG $0xc1ebfdc5 // vpor %ymm1, %ymm0, %ymm0 LONG $0x177de2c4; BYTE $0xc0 // vptest %ymm0, %ymm0 - LONG $0x020b840f; WORD $0x0000 // je LBB35_22, $523(%rip) + LONG $0x01fa840f; WORD $0x0000 // je LBB31_69, $506(%rip) -LBB35_43: - LONG $0xfd728d49 // leaq $-3(%r10), %rsi - WORD $0x894c; BYTE $0xc8 // movq %r9, %rax - WORD $0x394c; BYTE $0xce // cmpq %r9, %rsi - LONG $0x00de860f; WORD $0x0000 // jbe LBB35_57, $222(%rip) - WORD $0x894c; BYTE $0xc8 // movq %r9, %rax - LONG $0x000012e9; BYTE $0x00 // jmp LBB35_46, $18(%rip) +LBB31_39: + LONG $0xfd4e8d49 // leaq $-3(%r14), %rcx + WORD $0x894c; BYTE $0xc0 // movq %r8, %rax + WORD $0x3949; BYTE $0xc8 // cmpq %rcx, %r8 + LONG $0x00da830f; WORD $0x0000 // jae LBB31_53, $218(%rip) + WORD $0x894c; BYTE $0xc0 // movq %r8, %rax + LONG $0x000012e9; BYTE $0x00 // jmp LBB31_42, $18(%rip) LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 -LBB35_45: +LBB31_41: WORD $0x0148; BYTE $0xd0 // addq %rdx, %rax - WORD $0x3948; BYTE $0xf0 // cmpq %rsi, %rax - LONG $0x00c4830f; WORD $0x0000 // jae LBB35_57, $196(%rip) + WORD $0x3948; BYTE $0xc8 // cmpq %rcx, %rax + LONG $0x00c0830f; WORD $0x0000 // jae LBB31_53, $192(%rip) -LBB35_46: +LBB31_42: LONG $0x000001ba; BYTE $0x00 // movl $1, %edx WORD $0x3880; BYTE $0x00 // cmpb $0, (%rax) - LONG $0xffe6890f; WORD $0xffff // jns LBB35_45, $-26(%rip) - WORD $0x088b // movl (%rax), %ecx - WORD $0xca89 // movl %ecx, %edx + LONG $0xffe6890f; WORD $0xffff // jns LBB31_41, $-26(%rip) + WORD $0x308b // movl (%rax), %esi + WORD $0xf289 // movl %esi, %edx LONG $0xc0f0e281; WORD $0x00c0 // andl $12632304, %edx LONG $0x80e0fa81; WORD $0x0080 // cmpl $8421600, %edx - LONG $0x0030850f; WORD $0x0000 // jne LBB35_50, $48(%rip) - WORD $0xcf89 // movl %ecx, %edi + LONG $0x0030850f; WORD $0x0000 // jne LBB31_46, $48(%rip) + WORD $0xf789 // movl %esi, %edi LONG $0x200fe781; WORD $0x0000 // andl $8207, %edi LONG $0x200dff81; WORD $0x0000 // cmpl $8205, %edi - LONG $0x001c840f; WORD $0x0000 // je LBB35_50, $28(%rip) + LONG $0x001c840f; WORD $0x0000 // je LBB31_46, $28(%rip) LONG $0x000003ba; BYTE $0x00 // movl $3, %edx WORD $0xff85 // testl %edi, %edi - LONG $0xffaf850f; WORD $0xffff // jne LBB35_45, $-81(%rip) + LONG $0xffaf850f; WORD $0xffff // jne LBB31_41, $-81(%rip) QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 -LBB35_50: - WORD $0xca89 // movl %ecx, %edx +LBB31_46: + WORD $0xf289 // movl %esi, %edx LONG $0xc0e0e281; WORD $0x0000 // andl $49376, %edx LONG $0x80c0fa81; WORD $0x0000 // cmpl $32960, %edx - LONG $0x0010850f; WORD $0x0000 // jne LBB35_52, $16(%rip) - WORD $0xcf89 // movl %ecx, %edi + LONG $0x0010850f; WORD $0x0000 // jne LBB31_48, $16(%rip) + WORD $0xf789 // movl %esi, %edi LONG $0x000002ba; BYTE $0x00 // movl $2, %edx WORD $0xe783; BYTE $0x1e // andl $30, %edi - LONG $0xff7c850f; WORD $0xffff // jne LBB35_45, $-132(%rip) + LONG $0xff7c850f; WORD $0xffff // jne LBB31_41, $-132(%rip) -LBB35_52: - WORD $0xca89 // movl %ecx, %edx +LBB31_48: + WORD $0xf289 // movl %esi, %edx LONG $0xc0f8e281; WORD $0xc0c0 // andl $-1061109512, %edx LONG $0x80f0fa81; WORD $0x8080 // cmpl $-2139062032, %edx - LONG $0x0028850f; WORD $0x0000 // jne LBB35_56, $40(%rip) - WORD $0xca89 // movl %ecx, %edx + LONG $0x0029850f; WORD $0x0000 // jne LBB31_52, $41(%rip) + WORD $0xf289 // movl %esi, %edx LONG $0x3007e281; WORD $0x0000 // andl $12295, %edx - LONG $0x001a840f; WORD $0x0000 // je LBB35_56, $26(%rip) + LONG $0x001b840f; WORD $0x0000 // je LBB31_52, $27(%rip) LONG $0x000004ba; BYTE $0x00 // movl $4, %edx - WORD $0xc1f6; BYTE $0x04 // testb $4, %cl - LONG $0xff4c840f; WORD $0xffff // je LBB35_45, $-180(%rip) - LONG $0x3003e181; WORD $0x0000 // andl $12291, %ecx - LONG $0xff40840f; WORD $0xffff // je LBB35_45, $-192(%rip) + LONG $0x04c6f640 // testb $4, %sil + LONG $0xff4b840f; WORD $0xffff // je LBB31_41, $-181(%rip) + LONG $0x3003e681; WORD $0x0000 // andl $12291, %esi + LONG $0xff3f840f; WORD $0xffff // je LBB31_41, $-193(%rip) -LBB35_56: - WORD $0xf748; BYTE $0xd0 // notq %rax - WORD $0x014c; BYTE $0xc8 // addq %r9, %rax - LONG $0xf8658d48 // leaq $-8(%rbp), %rsp - BYTE $0x5b // popq %rbx - BYTE $0x5d // popq %rbp - WORD $0xf8c5; BYTE $0x77 // vzeroupper - BYTE $0xc3 // retq +LBB31_52: + WORD $0xf748; BYTE $0xd0 // notq %rax + WORD $0x014c; BYTE $0xc0 // addq %r8, %rax + LONG $0x000112e9; BYTE $0x00 // jmp LBB31_70, $274(%rip) -LBB35_57: - WORD $0x394c; BYTE $0xd0 // cmpq %r10, %rax - LONG $0x0114830f; WORD $0x0000 // jae LBB35_22, $276(%rip) - LONG $0x24448d4c; BYTE $0x20 // leaq $32(%rsp), %r8 - LONG $0x245c8d4c; BYTE $0x1e // leaq $30(%rsp), %r11 - LONG $0x000014e9; BYTE $0x00 // jmp LBB35_60, $20(%rip) - QUAD $0x9090909090909090 // .p2align 4, 0x90 +LBB31_53: + WORD $0x394c; BYTE $0xf0 // cmpq %r14, %rax + LONG $0x0107830f; WORD $0x0000 // jae LBB31_69, $263(%rip) + LONG $0x244c8d4c; BYTE $0x20 // leaq $32(%rsp), %r9 + LONG $0x24548d4c; BYTE $0x1e // leaq $30(%rsp), %r10 + LONG $0x000018e9; BYTE $0x00 // jmp LBB31_56, $24(%rip) + QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90 -LBB35_59: +LBB31_55: WORD $0xff48; BYTE $0xc0 // incq %rax - WORD $0x394c; BYTE $0xd0 // cmpq %r10, %rax - LONG $0x00f1830f; WORD $0x0000 // jae LBB35_22, $241(%rip) + WORD $0x394c; BYTE $0xf0 // cmpq %r14, %rax + LONG $0x00e0830f; WORD $0x0000 // jae LBB31_69, $224(%rip) -LBB35_60: +LBB31_56: WORD $0x3880; BYTE $0x00 // cmpb $0, (%rax) - LONG $0xffeb890f; WORD $0xffff // jns LBB35_59, $-21(%rip) + LONG $0xffeb890f; WORD $0xffff // jns LBB31_55, $-21(%rip) LONG $0x202444c6; BYTE $0x00 // movb $0, $32(%rsp) LONG $0x1e2444c6; BYTE $0x00 // movb $0, $30(%rsp) - WORD $0x894c; BYTE $0xd2 // movq %r10, %rdx + WORD $0x894c; BYTE $0xf2 // movq %r14, %rdx WORD $0x2948; BYTE $0xc2 // subq %rax, %rdx LONG $0x02fa8348 // cmpq $2, %rdx - LONG $0x0034820f; WORD $0x0000 // jb LBB35_64, $52(%rip) - WORD $0xb60f; BYTE $0x30 // movzbl (%rax), %esi - LONG $0x0148b60f // movzbl $1(%rax), %ecx - LONG $0x24748840; BYTE $0x20 // movb %sil, $32(%rsp) + LONG $0x0033820f; WORD $0x0000 // jb LBB31_60, $51(%rip) + WORD $0xb60f; BYTE $0x08 // movzbl (%rax), %ecx + LONG $0x0170b60f // movzbl $1(%rax), %esi + LONG $0x20244c88 // movb %cl, $32(%rsp) LONG $0x02788d48 // leaq $2(%rax), %rdi LONG $0xfec28348 // addq $-2, %rdx - WORD $0x894c; BYTE $0xdb // movq %r11, %rbx + WORD $0x894c; BYTE $0xd3 // movq %r10, %rbx WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx - LONG $0x0027840f; WORD $0x0000 // je LBB35_65, $39(%rip) + LONG $0x0027840f; WORD $0x0000 // je LBB31_61, $39(%rip) -LBB35_63: - WORD $0xb60f; BYTE $0x17 // movzbl (%rdi), %edx - WORD $0x1388 // movb %dl, (%rbx) - LONG $0x2474b60f; BYTE $0x20 // movzbl $32(%rsp), %esi +LBB31_59: + WORD $0xb60f; BYTE $0x0f // movzbl (%rdi), %ecx + WORD $0x0b88 // movb %cl, (%rbx) + LONG $0x244cb60f; BYTE $0x20 // movzbl $32(%rsp), %ecx LONG $0x2454b60f; BYTE $0x1e // movzbl $30(%rsp), %edx - LONG $0x000015e9; BYTE $0x00 // jmp LBB35_66, $21(%rip) + LONG $0x000015e9; BYTE $0x00 // jmp LBB31_62, $21(%rip) -LBB35_64: - WORD $0xf631 // xorl %esi, %esi +LBB31_60: WORD $0xc931 // xorl %ecx, %ecx - WORD $0x894c; BYTE $0xc3 // movq %r8, %rbx + WORD $0xf631 // xorl %esi, %esi + WORD $0x894c; BYTE $0xcb // movq %r9, %rbx WORD $0x8948; BYTE $0xc7 // movq %rax, %rdi WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx - LONG $0xffd9850f; WORD $0xffff // jne LBB35_63, $-39(%rip) + LONG $0xffd9850f; WORD $0xffff // jne LBB31_59, $-39(%rip) -LBB35_65: +LBB31_61: WORD $0xd231 // xorl %edx, %edx -LBB35_66: - WORD $0xb60f; BYTE $0xd2 // movzbl %dl, %edx - WORD $0xe2c1; BYTE $0x10 // shll $16, %edx - WORD $0xb60f; BYTE $0xf9 // movzbl %cl, %edi - WORD $0xe7c1; BYTE $0x08 // shll $8, %edi - WORD $0xd709 // orl %edx, %edi - LONG $0xceb60f40 // movzbl %sil, %ecx - WORD $0xf909 // orl %edi, %ecx - WORD $0xca89 // movl %ecx, %edx - LONG $0xc0f0e281; WORD $0x00c0 // andl $12632304, %edx - LONG $0x80e0fa81; WORD $0x0080 // cmpl $8421600, %edx - LONG $0x0030850f; WORD $0x0000 // jne LBB35_69, $48(%rip) - WORD $0xcf89 // movl %ecx, %edi - LONG $0x200fe781; WORD $0x0000 // andl $8207, %edi - LONG $0x200dff81; WORD $0x0000 // cmpl $8205, %edi - LONG $0x001c840f; WORD $0x0000 // je LBB35_69, $28(%rip) - LONG $0x000003ba; BYTE $0x00 // movl $3, %edx - WORD $0xff85 // testl %edi, %edi - LONG $0x0030850f; WORD $0x0000 // jne LBB35_71, $48(%rip) - QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 +LBB31_62: + WORD $0xb60f; BYTE $0xfa // movzbl %dl, %edi + WORD $0xe7c1; BYTE $0x10 // shll $16, %edi + LONG $0xf6b60f40 // movzbl %sil, %esi + WORD $0xe6c1; BYTE $0x08 // shll $8, %esi + WORD $0xb60f; BYTE $0xd1 // movzbl %cl, %edx + WORD $0xf209 // orl %esi, %edx + WORD $0xd709 // orl %edx, %edi + LONG $0xc0f0e781; WORD $0x00c0 // andl $12632304, %edi + LONG $0x80e0ff81; WORD $0x0080 // cmpl $8421600, %edi + LONG $0x0023850f; WORD $0x0000 // jne LBB31_65, $35(%rip) + WORD $0xd789 // movl %edx, %edi + LONG $0x200fe781; WORD $0x0000 // andl $8207, %edi + LONG $0x200dff81; WORD $0x0000 // cmpl $8205, %edi + LONG $0x000f840f; WORD $0x0000 // je LBB31_65, $15(%rip) + LONG $0x000003be; BYTE $0x00 // movl $3, %esi + WORD $0xff85 // testl %edi, %edi + LONG $0x0022850f; WORD $0x0000 // jne LBB31_67, $34(%rip) + WORD $0x9090 // .p2align 4, 0x90 -LBB35_69: - LONG $0x1ec6f640 // testb $30, %sil - LONG $0xfef6840f; WORD $0xffff // je LBB35_56, $-266(%rip) - LONG $0xc0e0e181; WORD $0x0000 // andl $49376, %ecx - LONG $0x000002ba; BYTE $0x00 // movl $2, %edx - LONG $0x80c0f981; WORD $0x0000 // cmpl $32960, %ecx - LONG $0xfedf850f; WORD $0xffff // jne LBB35_56, $-289(%rip) +LBB31_65: + WORD $0xc1f6; BYTE $0x1e // testb $30, %cl + LONG $0xff08840f; WORD $0xffff // je LBB31_52, $-248(%rip) + LONG $0xc0e0e281; WORD $0x0000 // andl $49376, %edx + LONG $0x000002be; BYTE $0x00 // movl $2, %esi + LONG $0x80c0fa81; WORD $0x0000 // cmpl $32960, %edx + LONG $0xfef1850f; WORD $0xffff // jne LBB31_52, $-271(%rip) -LBB35_71: - WORD $0x0148; BYTE $0xd0 // addq %rdx, %rax - WORD $0x394c; BYTE $0xd0 // cmpq %r10, %rax - LONG $0xff0f820f; WORD $0xffff // jb LBB35_60, $-241(%rip) +LBB31_67: + WORD $0x0148; BYTE $0xf0 // addq %rsi, %rax + WORD $0x394c; BYTE $0xf0 // cmpq %r14, %rax + LONG $0xff20820f; WORD $0xffff // jb LBB31_56, $-224(%rip) -LBB35_22: - WORD $0xc031 // xorl %eax, %eax - LONG $0xf8658d48 // leaq $-8(%rbp), %rsp +LBB31_69: + WORD $0xc031 // xorl %eax, %eax + +LBB31_70: + LONG $0xf0658d48 // leaq $-16(%rbp), %rsp BYTE $0x5b // popq %rbx + WORD $0x5e41 // popq %r14 BYTE $0x5d // popq %rbp WORD $0xf8c5; BYTE $0x77 // vzeroupper BYTE $0xc3 // retq -LBB35_42: - LONG $0x466de3c4; WORD $0x21d4 // vperm2i128 $33, %ymm4, %ymm2, %ymm2 - LONG $0x0f5de3c4; WORD $0x0fea // vpalignr $15, %ymm2, %ymm4, %ymm5 - LONG $0xd571cdc5; BYTE $0x04 // vpsrlw $4, %ymm5, %ymm6 - QUAD $0xfffff59e0d6ffdc5 // vmovdqa $-2658(%rip), %ymm1 /* LCPI35_0(%rip) */ - LONG $0xf1dbcdc5 // vpand %ymm1, %ymm6, %ymm6 - QUAD $0xfffff5b23d6ffdc5 // vmovdqa $-2638(%rip), %ymm7 /* LCPI35_1(%rip) */ - LONG $0x0045e2c4; BYTE $0xf6 // vpshufb %ymm6, %ymm7, %ymm6 - LONG $0xe9dbd5c5 // vpand %ymm1, %ymm5, %ymm5 - QUAD $0xfffff5c1056f7dc5 // vmovdqa $-2623(%rip), %ymm8 /* LCPI35_2(%rip) */ - LONG $0x003de2c4; BYTE $0xed // vpshufb %ymm5, %ymm8, %ymm5 - LONG $0xd471b5c5; BYTE $0x04 // vpsrlw $4, %ymm4, %ymm9 - LONG $0xc9db35c5 // vpand %ymm1, %ymm9, %ymm9 - QUAD $0xfffff5cb156f7dc5 // vmovdqa $-2613(%rip), %ymm10 /* LCPI35_3(%rip) */ - LONG $0x002d42c4; BYTE $0xc9 // vpshufb %ymm9, %ymm10, %ymm9 - LONG $0xeddbb5c5 // vpand %ymm5, %ymm9, %ymm5 - LONG $0xeddbcdc5 // vpand %ymm5, %ymm6, %ymm5 - LONG $0x0f5de3c4; WORD $0x0ef2 // vpalignr $14, %ymm2, %ymm4, %ymm6 - LONG $0x0f5de3c4; WORD $0x0dd2 // vpalignr $13, %ymm2, %ymm4, %ymm2 - QUAD $0xfffff5ca0d6f7dc5 // vmovdqa $-2614(%rip), %ymm9 /* LCPI35_4(%rip) */ - LONG $0xd84dc1c4; BYTE $0xf1 // vpsubusb %ymm9, %ymm6, %ymm6 - QUAD $0xfffff5dd1d6f7dc5 // vmovdqa $-2595(%rip), %ymm11 /* LCPI35_5(%rip) */ - LONG $0xd86dc1c4; BYTE $0xd3 // vpsubusb %ymm11, %ymm2, %ymm2 - LONG $0xd6ebedc5 // vpor %ymm6, %ymm2, %ymm2 - LONG $0xf6efc9c5 // vpxor %xmm6, %xmm6, %xmm6 - LONG $0xd674edc5 // vpcmpeqb %ymm6, %ymm2, %ymm2 - QUAD $0xfff62325597d62c4; BYTE $0xff // vpbroadcastq $-2525(%rip), %ymm12 /* LCPI35_6(%rip) */ - LONG $0xdf6dc1c4; BYTE $0xd4 // vpandn %ymm12, %ymm2, %ymm2 - LONG $0xd5efedc5 // vpxor %ymm5, %ymm2, %ymm2 - LONG $0x465de3c4; WORD $0x21e3 // vperm2i128 $33, %ymm3, %ymm4, %ymm4 - LONG $0x0f65e3c4; WORD $0x0fec // vpalignr $15, %ymm4, %ymm3, %ymm5 - LONG $0xd57195c5; BYTE $0x04 // vpsrlw $4, %ymm5, %ymm13 - LONG $0xe9db15c5 // vpand %ymm1, %ymm13, %ymm13 - LONG $0x0045c2c4; BYTE $0xfd // vpshufb %ymm13, %ymm7, %ymm7 - LONG $0xe9dbd5c5 // vpand %ymm1, %ymm5, %ymm5 - LONG $0x003de2c4; BYTE $0xed // vpshufb %ymm5, %ymm8, %ymm5 - LONG $0xd371bdc5; BYTE $0x04 // vpsrlw $4, %ymm3, %ymm8 - LONG $0xc9dbbdc5 // vpand %ymm1, %ymm8, %ymm1 - LONG $0x002de2c4; BYTE $0xc9 // vpshufb %ymm1, %ymm10, %ymm1 - LONG $0xc9dbd5c5 // vpand %ymm1, %ymm5, %ymm1 - LONG $0xc9dbc5c5 // vpand %ymm1, %ymm7, %ymm1 - LONG $0x0f65e3c4; WORD $0x0eec // vpalignr $14, %ymm4, %ymm3, %ymm5 - LONG $0x0f65e3c4; WORD $0x0de4 // vpalignr $13, %ymm4, %ymm3, %ymm4 - LONG $0xd855c1c4; BYTE $0xe9 // vpsubusb %ymm9, %ymm5, %ymm5 - LONG $0xd85dc1c4; BYTE $0xe3 // vpsubusb %ymm11, %ymm4, %ymm4 - LONG $0xe5ebddc5 // vpor %ymm5, %ymm4, %ymm4 - LONG $0xe674ddc5 // vpcmpeqb %ymm6, %ymm4, %ymm4 - LONG $0xdf5dc1c4; BYTE $0xe4 // vpandn %ymm12, %ymm4, %ymm4 - LONG $0xc9efddc5 // vpxor %ymm1, %ymm4, %ymm1 - LONG $0xc0ebedc5 // vpor %ymm0, %ymm2, %ymm0 - LONG $0xc1ebfdc5 // vpor %ymm1, %ymm0, %ymm0 - QUAD $0xfffff56a0dd8e5c5 // vpsubusb $-2710(%rip), %ymm3, %ymm1 /* LCPI35_7(%rip) */ - LONG $0xc1ebfdc5 // vpor %ymm1, %ymm0, %ymm0 - LONG $0x177de2c4; BYTE $0xc0 // vptest %ymm0, %ymm0 - LONG $0xfed8840f; WORD $0xffff // je LBB35_22, $-296(%rip) - LONG $0xfffcc8e9; BYTE $0xff // jmp LBB35_43, $-824(%rip) - QUAD $0x0000000000000000; QUAD $0x0000000000000000; LONG $0x00000000; WORD $0x0000 // .p2align 5, 0x00 +LBB31_24: + WORD $0x894d; BYTE $0xd3 // movq %r10, %r11 + LONG $0x80e38349 // andq $-128, %r11 + LONG $0x804b8d49 // leaq $-128(%r11), %rcx + WORD $0x8949; BYTE $0xc9 // movq %rcx, %r9 + LONG $0x07e9c149 // shrq $7, %r9 + WORD $0xff49; BYTE $0xc1 // incq %r9 + WORD $0x8548; BYTE $0xc9 // testq %rcx, %rcx + LONG $0x00f0840f; WORD $0x0000 // je LBB31_37, $240(%rip) + WORD $0x894c; BYTE $0xcf // movq %r9, %rdi + LONG $0xfee78348 // andq $-2, %rdi + WORD $0xf748; BYTE $0xdf // negq %rdi + WORD $0xc931 // xorl %ecx, %ecx + QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90 -LCPI36_0: - QUAD $0x3030303030303030; QUAD $0x3030303030303030 // .space 16, '0000000000000000' - QUAD $0x3030303030303030; QUAD $0x3030303030303030 // .space 16, '0000000000000000' +LBB31_26: + LONG $0x1c10fcc5; BYTE $0x0e // vmovups (%rsi,%rcx), %ymm3 + LONG $0x6410fcc5; WORD $0x200e // vmovups $32(%rsi,%rcx), %ymm4 + LONG $0x6c10fcc5; WORD $0x400e // vmovups $64(%rsi,%rcx), %ymm5 + LONG $0x7410fcc5; WORD $0x600e // vmovups $96(%rsi,%rcx), %ymm6 + LONG $0x5c11fcc5; WORD $0x200c // vmovups %ymm3, $32(%rsp,%rcx) + LONG $0x6411fcc5; WORD $0x400c // vmovups %ymm4, $64(%rsp,%rcx) + LONG $0x6c11fcc5; WORD $0x600c // vmovups %ymm5, $96(%rsp,%rcx) + QUAD $0x0000800cb411fcc5; BYTE $0x00 // vmovups %ymm6, $128(%rsp,%rcx) + QUAD $0x0000800e9c6ffec5; BYTE $0x00 // vmovdqu $128(%rsi,%rcx), %ymm3 + QUAD $0x0000a00ea46ffec5; BYTE $0x00 // vmovdqu $160(%rsi,%rcx), %ymm4 + QUAD $0x0000c00eac6ffec5; BYTE $0x00 // vmovdqu $192(%rsi,%rcx), %ymm5 + QUAD $0x0000e00eb46ffec5; BYTE $0x00 // vmovdqu $224(%rsi,%rcx), %ymm6 + QUAD $0x0000a00c9c7ffec5; BYTE $0x00 // vmovdqu %ymm3, $160(%rsp,%rcx) + QUAD $0x0000c00ca47ffec5; BYTE $0x00 // vmovdqu %ymm4, $192(%rsp,%rcx) + QUAD $0x0000e00cac7ffec5; BYTE $0x00 // vmovdqu %ymm5, $224(%rsp,%rcx) + QUAD $0x0001000cb47ffec5; BYTE $0x00 // vmovdqu %ymm6, $256(%rsp,%rcx) + LONG $0x00c18148; WORD $0x0001; BYTE $0x00 // addq $256, %rcx + LONG $0x02c78348 // addq $2, %rdi + LONG $0xff75850f; WORD $0xffff // jne LBB31_26, $-139(%rip) + LONG $0x01c1f641 // testb $1, %r9b + LONG $0x0032840f; WORD $0x0000 // je LBB31_29, $50(%rip) + +LBB31_28: + LONG $0x1c6ffec5; BYTE $0x0e // vmovdqu (%rsi,%rcx), %ymm3 + LONG $0x646ffec5; WORD $0x200e // vmovdqu $32(%rsi,%rcx), %ymm4 + LONG $0x6c6ffec5; WORD $0x400e // vmovdqu $64(%rsi,%rcx), %ymm5 + LONG $0x746ffec5; WORD $0x600e // vmovdqu $96(%rsi,%rcx), %ymm6 + LONG $0x5c7ffec5; WORD $0x200c // vmovdqu %ymm3, $32(%rsp,%rcx) + LONG $0x647ffec5; WORD $0x400c // vmovdqu %ymm4, $64(%rsp,%rcx) + LONG $0x6c7ffec5; WORD $0x600c // vmovdqu %ymm5, $96(%rsp,%rcx) + QUAD $0x0000800cb47ffec5; BYTE $0x00 // vmovdqu %ymm6, $128(%rsp,%rcx) - // .p2align 4, 0x00 -LCPI36_1: +LBB31_29: + WORD $0x394d; BYTE $0xd3 // cmpq %r10, %r11 + LONG $0xfcc3840f; WORD $0xffff // je LBB31_33, $-829(%rip) + WORD $0x014c; BYTE $0xde // addq %r11, %rsi + LONG $0xfffc99e9; BYTE $0xff // jmp LBB31_31, $-871(%rip) + +LBB31_37: + WORD $0xc931 // xorl %ecx, %ecx + LONG $0x01c1f641 // testb $1, %r9b + LONG $0xffb1850f; WORD $0xffff // jne LBB31_28, $-79(%rip) + LONG $0xffffdee9; BYTE $0xff // jmp LBB31_29, $-34(%rip) + +LBB31_38: + LONG $0x466de3c4; WORD $0x21d4 // vperm2i128 $33, %ymm4, %ymm2, %ymm2 + LONG $0x0f5de3c4; WORD $0x0fea // vpalignr $15, %ymm2, %ymm4, %ymm5 + LONG $0xd571cdc5; BYTE $0x04 // vpsrlw $4, %ymm5, %ymm6 + QUAD $0xfffff5ee0d6ffdc5 // vmovdqa $-2578(%rip), %ymm1 /* LCPI31_0(%rip) */ + LONG $0xf1dbcdc5 // vpand %ymm1, %ymm6, %ymm6 + QUAD $0xfffff6023d6ffdc5 // vmovdqa $-2558(%rip), %ymm7 /* LCPI31_1(%rip) */ + LONG $0x0045e2c4; BYTE $0xf6 // vpshufb %ymm6, %ymm7, %ymm6 + LONG $0xe9dbd5c5 // vpand %ymm1, %ymm5, %ymm5 + QUAD $0xfffff611056f7dc5 // vmovdqa $-2543(%rip), %ymm8 /* LCPI31_2(%rip) */ + LONG $0x003de2c4; BYTE $0xed // vpshufb %ymm5, %ymm8, %ymm5 + LONG $0xd471b5c5; BYTE $0x04 // vpsrlw $4, %ymm4, %ymm9 + LONG $0xc9db35c5 // vpand %ymm1, %ymm9, %ymm9 + QUAD $0xfffff61b156f7dc5 // vmovdqa $-2533(%rip), %ymm10 /* LCPI31_3(%rip) */ + LONG $0x002d42c4; BYTE $0xc9 // vpshufb %ymm9, %ymm10, %ymm9 + LONG $0xeddbb5c5 // vpand %ymm5, %ymm9, %ymm5 + LONG $0xeddbcdc5 // vpand %ymm5, %ymm6, %ymm5 + LONG $0x0f5de3c4; WORD $0x0ef2 // vpalignr $14, %ymm2, %ymm4, %ymm6 + LONG $0x0f5de3c4; WORD $0x0dd2 // vpalignr $13, %ymm2, %ymm4, %ymm2 + QUAD $0xfffff61a0d6f7dc5 // vmovdqa $-2534(%rip), %ymm9 /* LCPI31_4(%rip) */ + LONG $0xd84dc1c4; BYTE $0xf1 // vpsubusb %ymm9, %ymm6, %ymm6 + QUAD $0xfffff62d1d6f7dc5 // vmovdqa $-2515(%rip), %ymm11 /* LCPI31_5(%rip) */ + LONG $0xd86dc1c4; BYTE $0xd3 // vpsubusb %ymm11, %ymm2, %ymm2 + LONG $0xd6ebedc5 // vpor %ymm6, %ymm2, %ymm2 + LONG $0xf6efc9c5 // vpxor %xmm6, %xmm6, %xmm6 + LONG $0xd674edc5 // vpcmpeqb %ymm6, %ymm2, %ymm2 + QUAD $0xfff67325597d62c4; BYTE $0xff // vpbroadcastq $-2445(%rip), %ymm12 /* LCPI31_6(%rip) */ + LONG $0xdf6dc1c4; BYTE $0xd4 // vpandn %ymm12, %ymm2, %ymm2 + LONG $0xd5efedc5 // vpxor %ymm5, %ymm2, %ymm2 + LONG $0x465de3c4; WORD $0x21e3 // vperm2i128 $33, %ymm3, %ymm4, %ymm4 + LONG $0x0f65e3c4; WORD $0x0fec // vpalignr $15, %ymm4, %ymm3, %ymm5 + LONG $0xd57195c5; BYTE $0x04 // vpsrlw $4, %ymm5, %ymm13 + LONG $0xe9db15c5 // vpand %ymm1, %ymm13, %ymm13 + LONG $0x0045c2c4; BYTE $0xfd // vpshufb %ymm13, %ymm7, %ymm7 + LONG $0xe9dbd5c5 // vpand %ymm1, %ymm5, %ymm5 + LONG $0x003de2c4; BYTE $0xed // vpshufb %ymm5, %ymm8, %ymm5 + LONG $0xd371bdc5; BYTE $0x04 // vpsrlw $4, %ymm3, %ymm8 + LONG $0xc9dbbdc5 // vpand %ymm1, %ymm8, %ymm1 + LONG $0x002de2c4; BYTE $0xc9 // vpshufb %ymm1, %ymm10, %ymm1 + LONG $0xc9dbd5c5 // vpand %ymm1, %ymm5, %ymm1 + LONG $0xc9dbc5c5 // vpand %ymm1, %ymm7, %ymm1 + LONG $0x0f65e3c4; WORD $0x0eec // vpalignr $14, %ymm4, %ymm3, %ymm5 + LONG $0x0f65e3c4; WORD $0x0de4 // vpalignr $13, %ymm4, %ymm3, %ymm4 + LONG $0xd855c1c4; BYTE $0xe9 // vpsubusb %ymm9, %ymm5, %ymm5 + LONG $0xd85dc1c4; BYTE $0xe3 // vpsubusb %ymm11, %ymm4, %ymm4 + LONG $0xe5ebddc5 // vpor %ymm5, %ymm4, %ymm4 + LONG $0xe674ddc5 // vpcmpeqb %ymm6, %ymm4, %ymm4 + LONG $0xdf5dc1c4; BYTE $0xe4 // vpandn %ymm12, %ymm4, %ymm4 + LONG $0xc9efddc5 // vpxor %ymm1, %ymm4, %ymm1 + LONG $0xc0ebedc5 // vpor %ymm0, %ymm2, %ymm0 + LONG $0xc1ebfdc5 // vpor %ymm1, %ymm0, %ymm0 + QUAD $0xfffff5ba0dd8e5c5 // vpsubusb $-2630(%rip), %ymm3, %ymm1 /* LCPI31_7(%rip) */ + LONG $0xc1ebfdc5 // vpor %ymm1, %ymm0, %ymm0 + LONG $0x177de2c4; BYTE $0xc0 // vptest %ymm0, %ymm0 + LONG $0xfdb7840f; WORD $0xffff // je LBB31_69, $-585(%rip) + LONG $0xfffbb8e9; BYTE $0xff // jmp LBB31_39, $-1096(%rip) + LONG $0x00000000; WORD $0x0000 // .p2align 5, 0x00 + +LCPI32_0: + QUAD $0x3030303030303030; QUAD $0x3030303030303030 // .space 16, '0000000000000000' QUAD $0x3030303030303030; QUAD $0x3030303030303030 // .space 16, '0000000000000000' // .p2align 4, 0x90 @@ -10039,1004 +9756,904 @@ _f32toa: WORD $0x5541 // pushq %r13 WORD $0x5441 // pushq %r12 BYTE $0x53 // pushq %rbx - BYTE $0x50 // pushq %rax LONG $0xc07ef9c5 // vmovd %xmm0, %eax WORD $0xc189 // movl %eax, %ecx WORD $0xe9c1; BYTE $0x17 // shrl $23, %ecx - WORD $0xb60f; BYTE $0xd1 // movzbl %cl, %edx - LONG $0x00fffa81; WORD $0x0000 // cmpl $255, %edx - LONG $0x0df0840f; WORD $0x0000 // je LBB36_141, $3568(%rip) + WORD $0xb60f; BYTE $0xd9 // movzbl %cl, %ebx + LONG $0x00fffb81; WORD $0x0000 // cmpl $255, %ebx + LONG $0x0cf1840f; WORD $0x0000 // je LBB32_138, $3313(%rip) WORD $0x07c6; BYTE $0x2d // movb $45, (%rdi) WORD $0x8941; BYTE $0xc1 // movl %eax, %r9d LONG $0x1fe9c141 // shrl $31, %r9d - LONG $0x0f2c8d4e // leaq (%rdi,%r9), %r13 + LONG $0x0f048d4e // leaq (%rdi,%r9), %r8 LONG $0xffffffa9; BYTE $0x7f // testl $2147483647, %eax - LONG $0x01cd840f; WORD $0x0000 // je LBB36_6, $461(%rip) + LONG $0x01bf840f; WORD $0x0000 // je LBB32_11, $447(%rip) LONG $0x7fffff25; BYTE $0x00 // andl $8388607, %eax - WORD $0xd285 // testl %edx, %edx - LONG $0x0dd1840f; WORD $0x0000 // je LBB36_142, $3537(%rip) - LONG $0x00b88d44; WORD $0x8000; BYTE $0x00 // leal $8388608(%rax), %r15d - LONG $0x6a828d44; WORD $0xffff; BYTE $0xff // leal $-150(%rdx), %r8d - WORD $0x4a8d; BYTE $0x81 // leal $-127(%rdx), %ecx + WORD $0xdb85 // testl %ebx, %ebx + LONG $0x0cd3840f; WORD $0x0000 // je LBB32_139, $3283(%rip) + LONG $0x0000b08d; WORD $0x0080 // leal $8388608(%rax), %esi + LONG $0x6abb8d44; WORD $0xffff; BYTE $0xff // leal $-150(%rbx), %r15d + WORD $0x4b8d; BYTE $0x81 // leal $-127(%rbx), %ecx WORD $0xf983; BYTE $0x17 // cmpl $23, %ecx - LONG $0x001c870f; WORD $0x0000 // ja LBB36_7, $28(%rip) - LONG $0x000096b9; BYTE $0x00 // movl $150, %ecx - WORD $0xd129 // subl %edx, %ecx - LONG $0xffc3c748; WORD $0xffff; BYTE $0xff // movq $-1, %rbx - WORD $0xd348; BYTE $0xe3 // shlq %cl, %rbx - WORD $0xd3f7 // notl %ebx - WORD $0x8544; BYTE $0xfb // testl %r15d, %ebx - LONG $0x043c840f; WORD $0x0000 // je LBB36_33, $1084(%rip) - -LBB36_7: - LONG $0xd07d8948 // movq %rdi, $-48(%rbp) - -LBB36_8: - WORD $0x8945; BYTE $0xfe // movl %r15d, %r14d + LONG $0x0019870f; WORD $0x0000 // ja LBB32_5, $25(%rip) + WORD $0x8944; BYTE $0xf9 // movl %r15d, %ecx + WORD $0xd9f7 // negl %ecx + LONG $0xffc2c748; WORD $0xffff; BYTE $0xff // movq $-1, %rdx + WORD $0xd348; BYTE $0xe2 // shlq %cl, %rdx + WORD $0xd2f7 // notl %edx + WORD $0xf285 // testl %esi, %edx + LONG $0x03fc840f; WORD $0x0000 // je LBB32_32, $1020(%rip) + +LBB32_5: + WORD $0x8941; BYTE $0xf6 // movl %esi, %r14d LONG $0x01e68341 // andl $1, %r14d WORD $0xc085 // testl %eax, %eax WORD $0x940f; BYTE $0xc0 // sete %al - WORD $0xfa83; BYTE $0x02 // cmpl $2, %edx - WORD $0x930f; BYTE $0xc1 // setae %cl + WORD $0xfb83; BYTE $0x01 // cmpl $1, %ebx + WORD $0x970f; BYTE $0xc1 // seta %cl WORD $0xc120 // andb %al, %cl WORD $0xb60f; BYTE $0xc9 // movzbl %cl, %ecx - WORD $0x8945; BYTE $0xfa // movl %r15d, %r10d + WORD $0x8941; BYTE $0xf2 // movl %esi, %r10d LONG $0x02e2c141 // shll $2, %r10d - LONG $0xb9048d42 // leal (%rcx,%r15,4), %eax - WORD $0xc083; BYTE $0xfe // addl $-2, %eax - LONG $0x13d06941; WORD $0x1344; BYTE $0x00 // imull $1262611, %r8d, %edx - LONG $0x019a8d44; WORD $0xf801; BYTE $0xff // leal $-524031(%rdx), %r11d + LONG $0xfeb1448d // leal $-2(%rcx,%rsi,4), %eax + LONG $0x13d76941; WORD $0x1344; BYTE $0x00 // imull $1262611, %r15d, %edx + WORD $0xdb31 // xorl %ebx, %ebx WORD $0xc984 // testb %cl, %cl - LONG $0xda440f44 // cmovel %edx, %r11d + LONG $0x0101bb41; WORD $0xfff8 // movl $-524031, %r11d + LONG $0xdb440f44 // cmovel %ebx, %r11d + WORD $0x0141; BYTE $0xd3 // addl %edx, %r11d LONG $0x16fbc141 // sarl $22, %r11d LONG $0xb1cb6941; WORD $0xe56c; BYTE $0xff // imull $-1741647, %r11d, %ecx WORD $0xe9c1; BYTE $0x13 // shrl $19, %ecx - WORD $0x0144; BYTE $0xc1 // addl %r8d, %ecx + WORD $0x0144; BYTE $0xf9 // addl %r15d, %ecx LONG $0x00001fba; BYTE $0x00 // movl $31, %edx WORD $0x2944; BYTE $0xda // subl %r11d, %edx - LONG $0x713d8d48; WORD $0x00b8; BYTE $0x00 // leaq $47217(%rip), %rdi /* _pow10_ceil_sig_f32.g(%rip) */ + LONG $0x291d8d48; WORD $0x00b4; BYTE $0x00 // leaq $46121(%rip), %rbx /* _pow10_ceil_sig_f32.g(%rip) */ WORD $0xc1fe // incb %cl WORD $0xe0d3 // shll %cl, %eax - LONG $0xd7248b4c // movq (%rdi,%rdx,8), %r12 + LONG $0xd3248b4c // movq (%rbx,%rdx,8), %r12 WORD $0xf749; BYTE $0xe4 // mulq %r12 - QUAD $0x00000002bd048d46 // leal $2(,%r15,4), %r8d - WORD $0xf631 // xorl %esi, %esi - LONG $0x21e8c148 // shrq $33, %rax - LONG $0xc6950f40 // setne %sil - WORD $0xd609 // orl %edx, %esi + LONG $0x20e8c148 // shrq $32, %rax + WORD $0xdb31 // xorl %ebx, %ebx + WORD $0xf883; BYTE $0x01 // cmpl $1, %eax + WORD $0x970f; BYTE $0xc3 // seta %bl WORD $0xd341; BYTE $0xe2 // shll %cl, %r10d + WORD $0xd309 // orl %edx, %ebx WORD $0x894c; BYTE $0xd0 // movq %r10, %rax WORD $0xf749; BYTE $0xe4 // mulq %r12 WORD $0x8949; BYTE $0xd2 // movq %rdx, %r10 + LONG $0x20e8c148 // shrq $32, %rax WORD $0x3145; BYTE $0xff // xorl %r15d, %r15d - LONG $0x21e8c148 // shrq $33, %rax - LONG $0xc7950f41 // setne %r15b + WORD $0xf883; BYTE $0x01 // cmpl $1, %eax + LONG $0xc7970f41 // seta %r15b + LONG $0x02b5048d; WORD $0x0000; BYTE $0x00 // leal $2(,%rsi,4), %eax + WORD $0xe0d3 // shll %cl, %eax WORD $0x0945; BYTE $0xd7 // orl %r10d, %r15d - WORD $0xd341; BYTE $0xe0 // shll %cl, %r8d - WORD $0x894c; BYTE $0xc0 // movq %r8, %rax WORD $0xf749; BYTE $0xe4 // mulq %r12 + LONG $0x20e8c148 // shrq $32, %rax WORD $0xc931 // xorl %ecx, %ecx - LONG $0x21e8c148 // shrq $33, %rax - WORD $0x950f; BYTE $0xc1 // setne %cl + WORD $0xf883; BYTE $0x01 // cmpl $1, %eax + WORD $0x970f; BYTE $0xc1 // seta %cl WORD $0xd109 // orl %edx, %ecx - WORD $0x0144; BYTE $0xf6 // addl %r14d, %esi + WORD $0x0144; BYTE $0xf3 // addl %r14d, %ebx WORD $0x2944; BYTE $0xf1 // subl %r14d, %ecx LONG $0x28ff8341 // cmpl $40, %r15d - LONG $0x0041820f; WORD $0x0000 // jb LBB36_10, $65(%rip) + LONG $0x003d820f; WORD $0x0000 // jb LBB32_7, $61(%rip) WORD $0x8944; BYTE $0xd0 // movl %r10d, %eax - LONG $0xcccccdba; BYTE $0xcc // movl $3435973837, %edx - LONG $0xd0af0f48 // imulq %rax, %rdx - LONG $0x25eac148 // shrq $37, %rdx - WORD $0xf089 // movl %esi, %eax - QUAD $0x00000000d53c8d48 // leaq (,%rdx,8), %rdi - LONG $0xbf1c8d48 // leaq (%rdi,%rdi,4), %rbx - WORD $0x3948; BYTE $0xc3 // cmpq %rax, %rbx + LONG $0xcccdbd41; WORD $0xcccc // movl $3435973837, %r13d + LONG $0xe8af0f4c // imulq %rax, %r13 + LONG $0x25edc149 // shrq $37, %r13 + WORD $0x8941; BYTE $0xde // movl %ebx, %r14d + QUAD $0x00000000ed348d4a // leaq (,%r13,8), %rsi + LONG $0xb6048d48 // leaq (%rsi,%rsi,4), %rax + WORD $0x394c; BYTE $0xf0 // cmpq %r14, %rax LONG $0xc6920f41 // setb %r14b - LONG $0xbf3c8d48 // leaq (%rdi,%rdi,4), %rdi - LONG $0x28c78348 // addq $40, %rdi - WORD $0xcb89 // movl %ecx, %ebx - WORD $0xc031 // xorl %eax, %eax - WORD $0x3948; BYTE $0xdf // cmpq %rbx, %rdi - LONG $0xc0960f41 // setbe %r8b - WORD $0x3845; BYTE $0xc6 // cmpb %r8b, %r14b - LONG $0x01f9840f; WORD $0x0000 // je LBB36_18, $505(%rip) + LONG $0xb6648d4c; BYTE $0x28 // leaq $40(%rsi,%rsi,4), %r12 + WORD $0xce89 // movl %ecx, %esi + WORD $0x3949; BYTE $0xf4 // cmpq %rsi, %r12 + WORD $0x960f; BYTE $0xc0 // setbe %al + WORD $0x3044; BYTE $0xf0 // xorb %r14b, %al + LONG $0x01e9840f; WORD $0x0000 // je LBB32_16, $489(%rip) -LBB36_10: - WORD $0x8945; BYTE $0xd0 // movl %r10d, %r8d - LONG $0x02e8c141 // shrl $2, %r8d - WORD $0x8944; BYTE $0xd2 // movl %r10d, %edx - WORD $0xe283; BYTE $0xfc // andl $-4, %edx - WORD $0xd639 // cmpl %edx, %esi - LONG $0xc6970f40 // seta %sil - WORD $0x428d; BYTE $0x04 // leal $4(%rdx), %eax - WORD $0xc839 // cmpl %ecx, %eax +LBB32_7: + WORD $0x894c; BYTE $0xd0 // movq %r10, %rax + LONG $0x02e8c148 // shrq $2, %rax + WORD $0x8944; BYTE $0xd6 // movl %r10d, %esi + WORD $0xe683; BYTE $0xfc // andl $-4, %esi + WORD $0xf339 // cmpl %esi, %ebx + LONG $0xc6970f41 // seta %r14b + WORD $0x568d; BYTE $0x04 // leal $4(%rsi), %edx + WORD $0xca39 // cmpl %ecx, %edx WORD $0x960f; BYTE $0xc3 // setbe %bl - WORD $0x3040; BYTE $0xf3 // xorb %sil, %bl - LONG $0x007e840f; WORD $0x0000 // je LBB36_14, $126(%rip) - WORD $0xca83; BYTE $0x02 // orl $2, %edx - LONG $0x000001b8; BYTE $0x00 // movl $1, %eax - WORD $0x3941; BYTE $0xd7 // cmpl %edx, %r15d - LONG $0x000e870f; WORD $0x0000 // ja LBB36_13, $14(%rip) - WORD $0x940f; BYTE $0xc0 // sete %al + WORD $0x3044; BYTE $0xf3 // xorb %r14b, %bl + LONG $0x0074840f; WORD $0x0000 // je LBB32_12, $116(%rip) + WORD $0xce83; BYTE $0x02 // orl $2, %esi + LONG $0x0001bd41; WORD $0x0000 // movl $1, %r13d + WORD $0x3941; BYTE $0xf7 // cmpl %esi, %r15d + LONG $0x000e870f; WORD $0x0000 // ja LBB32_10, $14(%rip) + WORD $0x940f; BYTE $0xc1 // sete %cl LONG $0x02eac041 // shrb $2, %r10b - WORD $0x2041; BYTE $0xc2 // andb %al, %r10b - LONG $0xc2b60f41 // movzbl %r10b, %eax + WORD $0x2041; BYTE $0xca // andb %cl, %r10b + LONG $0xeab60f45 // movzbl %r10b, %r13d -LBB36_13: - WORD $0x0144; BYTE $0xc0 // addl %r8d, %eax - WORD $0x894d; BYTE $0xef // movq %r13, %r15 - LONG $0x0186a03d; BYTE $0x00 // cmpl $100000, %eax - LONG $0xd06d8b4c // movq $-48(%rbp), %r13 - LONG $0x0065820f; WORD $0x0000 // jb LBB36_19, $101(%rip) - -LBB36_15: - LONG $0x0006bc41; WORD $0x0000 // movl $6, %r12d - LONG $0x0f42403d; BYTE $0x00 // cmpl $1000000, %eax - LONG $0x0093820f; WORD $0x0000 // jb LBB36_23, $147(%rip) - LONG $0x0007bc41; WORD $0x0000 // movl $7, %r12d - LONG $0x9896803d; BYTE $0x00 // cmpl $10000000, %eax - LONG $0x0082820f; WORD $0x0000 // jb LBB36_23, $130(%rip) - WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d - LONG $0xf5e1003d; BYTE $0x05 // cmpl $100000000, %eax - LONG $0xc4920f41 // setb %r12b - LONG $0x09f48341 // xorl $9, %r12d - LONG $0x00006de9; BYTE $0x00 // jmp LBB36_23, $109(%rip) +LBB32_10: + WORD $0x0141; BYTE $0xc5 // addl %eax, %r13d + LONG $0xa0fd8141; WORD $0x0186; BYTE $0x00 // cmpl $100000, %r13d + LONG $0x0059820f; WORD $0x0000 // jb LBB32_17, $89(%rip) + +LBB32_13: + LONG $0x000006be; BYTE $0x00 // movl $6, %esi + LONG $0x40fd8141; WORD $0x0f42; BYTE $0x00 // cmpl $1000000, %r13d + LONG $0x0086820f; WORD $0x0000 // jb LBB32_22, $134(%rip) + LONG $0x000007be; BYTE $0x00 // movl $7, %esi + LONG $0x80fd8141; WORD $0x9896; BYTE $0x00 // cmpl $10000000, %r13d + LONG $0x0074820f; WORD $0x0000 // jb LBB32_22, $116(%rip) + LONG $0x00fd8141; WORD $0xf5e1; BYTE $0x05 // cmpl $100000000, %r13d + LONG $0x000009be; BYTE $0x00 // movl $9, %esi + LONG $0x000060e9; BYTE $0x00 // jmp LBB32_21, $96(%rip) + +LBB32_11: + LONG $0x3000c641 // movb $48, (%r8) + WORD $0x2941; BYTE $0xf8 // subl %edi, %r8d + WORD $0xff41; BYTE $0xc0 // incl %r8d + LONG $0x000af9e9; BYTE $0x00 // jmp LBB32_137, $2809(%rip) -LBB36_6: - LONG $0x0045c641; BYTE $0x30 // movb $48, (%r13) - WORD $0x2941; BYTE $0xfd // subl %edi, %r13d - WORD $0xff41; BYTE $0xc5 // incl %r13d - WORD $0x8944; BYTE $0xe8 // movl %r13d, %eax - LONG $0x000be5e9; BYTE $0x00 // jmp LBB36_93, $3045(%rip) +LBB32_12: + WORD $0xd139 // cmpl %edx, %ecx + WORD $0xd883; BYTE $0xff // sbbl $-1, %eax + WORD $0x8941; BYTE $0xc5 // movl %eax, %r13d + LONG $0xa0fd8141; WORD $0x0186; BYTE $0x00 // cmpl $100000, %r13d + LONG $0xffa7830f; WORD $0xffff // jae LBB32_13, $-89(%rip) -LBB36_14: - WORD $0xc139 // cmpl %eax, %ecx - LONG $0xffd88341 // sbbl $-1, %r8d - WORD $0x8944; BYTE $0xc0 // movl %r8d, %eax - WORD $0x894d; BYTE $0xef // movq %r13, %r15 - LONG $0x0186a03d; BYTE $0x00 // cmpl $100000, %eax - LONG $0xd06d8b4c // movq $-48(%rbp), %r13 - LONG $0xff9b830f; WORD $0xffff // jae LBB36_15, $-101(%rip) +LBB32_17: + LONG $0x000001be; BYTE $0x00 // movl $1, %esi + LONG $0x0afd8341 // cmpl $10, %r13d + LONG $0x0030820f; WORD $0x0000 // jb LBB32_22, $48(%rip) + LONG $0x000002be; BYTE $0x00 // movl $2, %esi + LONG $0x64fd8341 // cmpl $100, %r13d + LONG $0x0021820f; WORD $0x0000 // jb LBB32_22, $33(%rip) + LONG $0x000003be; BYTE $0x00 // movl $3, %esi + LONG $0xe8fd8141; WORD $0x0003; BYTE $0x00 // cmpl $1000, %r13d + LONG $0x000f820f; WORD $0x0000 // jb LBB32_22, $15(%rip) + LONG $0x10fd8141; WORD $0x0027; BYTE $0x00 // cmpl $10000, %r13d + LONG $0x000005be; BYTE $0x00 // movl $5, %esi -LBB36_19: - LONG $0x0001bc41; WORD $0x0000 // movl $1, %r12d - WORD $0xf883; BYTE $0x0a // cmpl $10, %eax - LONG $0x0030820f; WORD $0x0000 // jb LBB36_23, $48(%rip) - LONG $0x0002bc41; WORD $0x0000 // movl $2, %r12d - WORD $0xf883; BYTE $0x64 // cmpl $100, %eax - LONG $0x0021820f; WORD $0x0000 // jb LBB36_23, $33(%rip) - LONG $0x0003bc41; WORD $0x0000 // movl $3, %r12d - LONG $0x0003e83d; BYTE $0x00 // cmpl $1000, %eax - LONG $0x0010820f; WORD $0x0000 // jb LBB36_23, $16(%rip) - WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d - LONG $0x0027103d; BYTE $0x00 // cmpl $10000, %eax - LONG $0xc4920f41 // setb %r12b - LONG $0x05f48341 // xorl $5, %r12d +LBB32_21: + WORD $0xde83; BYTE $0x00 // sbbl $0, %esi -LBB36_23: - LONG $0x1c148d47 // leal (%r12,%r11), %r10d - LONG $0x1c0c8d43 // leal (%r12,%r11), %ecx - WORD $0xc183; BYTE $0xea // addl $-22, %ecx - WORD $0xf983; BYTE $0xe4 // cmpl $-28, %ecx - LONG $0x0077870f; WORD $0x0000 // ja LBB36_27, $119(%rip) - WORD $0x8944; BYTE $0xe1 // movl %r12d, %ecx - LONG $0x0f148d49 // leaq (%r15,%rcx), %rdx - WORD $0xff48; BYTE $0xc2 // incq %rdx - LONG $0x0027103d; BYTE $0x00 // cmpl $10000, %eax - LONG $0x00f3820f; WORD $0x0000 // jb LBB36_31, $243(%rip) - WORD $0xc789 // movl %eax, %edi - LONG $0xb71759be; BYTE $0xd1 // movl $3518437209, %esi - LONG $0xf7af0f48 // imulq %rdi, %rsi - LONG $0x2deec148 // shrq $45, %rsi - LONG $0xf0c66944; WORD $0xffd8; BYTE $0xff // imull $-10000, %esi, %r8d - WORD $0x0141; BYTE $0xc0 // addl %eax, %r8d - LONG $0x0464840f; WORD $0x0000 // je LBB36_59, $1124(%rip) - WORD $0x8944; BYTE $0xc0 // movl %r8d, %eax - LONG $0x1fc06948; WORD $0xeb85; BYTE $0x51 // imulq $1374389535, %rax, %rax - LONG $0x25e8c148 // shrq $37, %rax - WORD $0xf86b; BYTE $0x64 // imull $100, %eax, %edi - WORD $0x2941; BYTE $0xf8 // subl %edi, %r8d - LONG $0xf43d8d48; WORD $0x0042; BYTE $0x00 // leaq $17140(%rip), %rdi /* _Digits(%rip) */ - LONG $0x1cb70f42; BYTE $0x47 // movzwl (%rdi,%r8,2), %ebx - LONG $0xfe5a8966 // movw %bx, $-2(%rdx) - LONG $0x4704b70f // movzwl (%rdi,%rax,2), %eax - LONG $0xfc428966 // movw %ax, $-4(%rdx) - WORD $0x3145; BYTE $0xc0 // xorl %r8d, %r8d - LONG $0xfcc28348 // addq $-4, %rdx - WORD $0xfe83; BYTE $0x64 // cmpl $100, %esi - LONG $0x00a6830f; WORD $0x0000 // jae LBB36_61, $166(%rip) +LBB32_22: + LONG $0x1e148d46 // leal (%rsi,%r11), %r10d + LONG $0x1e448d42; BYTE $0x05 // leal $5(%rsi,%r11), %eax + WORD $0xf883; BYTE $0x1b // cmpl $27, %eax + LONG $0x0075820f; WORD $0x0000 // jb LBB32_26, $117(%rip) + WORD $0xf089 // movl %esi, %eax + LONG $0x00748d4d; BYTE $0x01 // leaq $1(%r8,%rax), %r14 + LONG $0x10fd8141; WORD $0x0027; BYTE $0x00 // cmpl $10000, %r13d + LONG $0x00f3820f; WORD $0x0000 // jb LBB32_30, $243(%rip) + WORD $0x8944; BYTE $0xe8 // movl %r13d, %eax + LONG $0xb71759bb; BYTE $0xd1 // movl $3518437209, %ebx + LONG $0xd8af0f48 // imulq %rax, %rbx + LONG $0x2debc148 // shrq $45, %rbx + LONG $0xd8f0c369; WORD $0xffff // imull $-10000, %ebx, %eax + WORD $0x0144; BYTE $0xe8 // addl %r13d, %eax + LONG $0x048b840f; WORD $0x0000 // je LBB32_62, $1163(%rip) + WORD $0xc189 // movl %eax, %ecx + LONG $0x1fc96948; WORD $0xeb85; BYTE $0x51 // imulq $1374389535, %rcx, %rcx + LONG $0x25e9c148 // shrq $37, %rcx + WORD $0xd16b; BYTE $0x64 // imull $100, %ecx, %edx + WORD $0xd029 // subl %edx, %eax + LONG $0xc2158d48; WORD $0x003e; BYTE $0x00 // leaq $16066(%rip), %rdx /* _Digits(%rip) */ + LONG $0x4204b70f // movzwl (%rdx,%rax,2), %eax + LONG $0x46894166; BYTE $0xfe // movw %ax, $-2(%r14) + LONG $0x4a04b70f // movzwl (%rdx,%rcx,2), %eax + LONG $0x46894166; BYTE $0xfc // movw %ax, $-4(%r14) + WORD $0x3145; BYTE $0xc9 // xorl %r9d, %r9d + LONG $0xfc4e8d49 // leaq $-4(%r14), %rcx + WORD $0xfb83; BYTE $0x64 // cmpl $100, %ebx + LONG $0x00ab830f; WORD $0x0000 // jae LBB32_64, $171(%rip) -LBB36_32: - WORD $0xf089 // movl %esi, %eax - LONG $0x0000dbe9; BYTE $0x00 // jmp LBB36_63, $219(%rip) +LBB32_31: + WORD $0xda89 // movl %ebx, %edx + LONG $0x0000e8e9; BYTE $0x00 // jmp LBB32_66, $232(%rip) -LBB36_27: - WORD $0x8945; BYTE $0xe0 // movl %r12d, %r8d +LBB32_26: + WORD $0x8941; BYTE $0xf4 // movl %esi, %r12d WORD $0x8545; BYTE $0xdb // testl %r11d, %r11d - LONG $0x023a880f; WORD $0x0000 // js LBB36_36, $570(%rip) - LONG $0x070c8d4b // leaq (%r15,%r8), %rcx - LONG $0x0027103d; BYTE $0x00 // cmpl $10000, %eax - LONG $0x0295820f; WORD $0x0000 // jb LBB36_41, $661(%rip) - WORD $0xc289 // movl %eax, %edx - LONG $0xb71759be; BYTE $0xd1 // movl $3518437209, %esi - LONG $0xf2af0f48 // imulq %rdx, %rsi - LONG $0x2deec148 // shrq $45, %rsi - LONG $0xd8f0d669; WORD $0xffff // imull $-10000, %esi, %edx - WORD $0xc201 // addl %eax, %edx - LONG $0x1fc26948; WORD $0xeb85; BYTE $0x51 // imulq $1374389535, %rdx, %rax - LONG $0x25e8c148 // shrq $37, %rax - WORD $0xf86b; BYTE $0x64 // imull $100, %eax, %edi - WORD $0xfa29 // subl %edi, %edx - LONG $0x833d8d48; WORD $0x0042; BYTE $0x00 // leaq $17027(%rip), %rdi /* _Digits(%rip) */ - LONG $0x5714b70f // movzwl (%rdi,%rdx,2), %edx - LONG $0xfe518966 // movw %dx, $-2(%rcx) - LONG $0xfc518d48 // leaq $-4(%rcx), %rdx - LONG $0x4704b70f // movzwl (%rdi,%rax,2), %eax - LONG $0xfc418966 // movw %ax, $-4(%rcx) - WORD $0xf089 // movl %esi, %eax - WORD $0x8945; BYTE $0xd3 // movl %r10d, %r11d - WORD $0xf883; BYTE $0x64 // cmpl $100, %eax - LONG $0x0254830f; WORD $0x0000 // jae LBB36_42, $596(%rip) + LONG $0x021d880f; WORD $0x0000 // js LBB32_38, $541(%rip) + LONG $0x20348d4b // leaq (%r8,%r12), %rsi + LONG $0x10fd8141; WORD $0x0027; BYTE $0x00 // cmpl $10000, %r13d + LONG $0x028d820f; WORD $0x0000 // jb LBB32_43, $653(%rip) + WORD $0x8944; BYTE $0xe8 // movl %r13d, %eax + LONG $0xb71759b9; BYTE $0xd1 // movl $3518437209, %ecx + LONG $0xc8af0f48 // imulq %rax, %rcx + LONG $0x2de9c148 // shrq $45, %rcx + LONG $0xd8f0c169; WORD $0xffff // imull $-10000, %ecx, %eax + WORD $0x0144; BYTE $0xe8 // addl %r13d, %eax + LONG $0x1fd06948; WORD $0xeb85; BYTE $0x51 // imulq $1374389535, %rax, %rdx + LONG $0x25eac148 // shrq $37, %rdx + WORD $0xda6b; BYTE $0x64 // imull $100, %edx, %ebx + WORD $0xd829 // subl %ebx, %eax + LONG $0x4c1d8d48; WORD $0x003e; BYTE $0x00 // leaq $15948(%rip), %rbx /* _Digits(%rip) */ + LONG $0x4304b70f // movzwl (%rbx,%rax,2), %eax + LONG $0xfe468966 // movw %ax, $-2(%rsi) + LONG $0xfc468d48 // leaq $-4(%rsi), %rax + LONG $0x5314b70f // movzwl (%rbx,%rdx,2), %edx + LONG $0xfc568966 // movw %dx, $-4(%rsi) + WORD $0x8941; BYTE $0xcd // movl %ecx, %r13d + LONG $0x64fd8341 // cmpl $100, %r13d + LONG $0x0249830f; WORD $0x0000 // jae LBB32_44, $585(%rip) -LBB36_30: - WORD $0xc689 // movl %eax, %esi - LONG $0x000288e9; BYTE $0x00 // jmp LBB36_44, $648(%rip) +LBB32_29: + WORD $0x8944; BYTE $0xe9 // movl %r13d, %ecx + LONG $0x000286e9; BYTE $0x00 // jmp LBB32_46, $646(%rip) -LBB36_18: - WORD $0x8844; BYTE $0xc0 // movb %r8b, %al - WORD $0xd001 // addl %edx, %eax - WORD $0xff41; BYTE $0xc3 // incl %r11d - WORD $0x894d; BYTE $0xef // movq %r13, %r15 - LONG $0x0186a03d; BYTE $0x00 // cmpl $100000, %eax - LONG $0xd06d8b4c // movq $-48(%rbp), %r13 - LONG $0xfe45830f; WORD $0xffff // jae LBB36_15, $-443(%rip) - LONG $0xfffea5e9; BYTE $0xff // jmp LBB36_19, $-347(%rip) +LBB32_16: + WORD $0x394c; BYTE $0xe6 // cmpq %r12, %rsi + LONG $0xffdd8341 // sbbl $-1, %r13d + WORD $0xff41; BYTE $0xc3 // incl %r11d + LONG $0xa0fd8141; WORD $0x0186; BYTE $0x00 // cmpl $100000, %r13d + LONG $0xfe54830f; WORD $0xffff // jae LBB32_13, $-428(%rip) + LONG $0xfffea8e9; BYTE $0xff // jmp LBB32_17, $-344(%rip) -LBB36_31: - WORD $0x3145; BYTE $0xc0 // xorl %r8d, %r8d - WORD $0xc689 // movl %eax, %esi - WORD $0xfe83; BYTE $0x64 // cmpl $100, %esi - LONG $0xff5a820f; WORD $0xffff // jb LBB36_32, $-166(%rip) +LBB32_30: + WORD $0x3145; BYTE $0xc9 // xorl %r9d, %r9d + WORD $0x894c; BYTE $0xf1 // movq %r14, %rcx + WORD $0x8944; BYTE $0xeb // movl %r13d, %ebx + WORD $0xfb83; BYTE $0x64 // cmpl $100, %ebx + LONG $0xff55820f; WORD $0xffff // jb LBB32_31, $-171(%rip) -LBB36_61: - WORD $0xff48; BYTE $0xca // decq %rdx - LONG $0x231d8d4c; WORD $0x0042; BYTE $0x00 // leaq $16931(%rip), %r11 /* _Digits(%rip) */ - WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 +LBB32_64: + WORD $0xff48; BYTE $0xc9 // decq %rcx + LONG $0xeb1d8d4c; WORD $0x003d; BYTE $0x00 // leaq $15851(%rip), %r11 /* _Digits(%rip) */ + QUAD $0x9090909090909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 -LBB36_62: - WORD $0xf089 // movl %esi, %eax - LONG $0x1fc06948; WORD $0xeb85; BYTE $0x51 // imulq $1374389535, %rax, %rax - LONG $0x25e8c148 // shrq $37, %rax - WORD $0xf86b; BYTE $0x64 // imull $100, %eax, %edi - WORD $0xf389 // movl %esi, %ebx - WORD $0xfb29 // subl %edi, %ebx - LONG $0x3cb70f41; BYTE $0x5b // movzwl (%r11,%rbx,2), %edi - LONG $0xff7a8966 // movw %di, $-1(%rdx) - LONG $0xfec28348 // addq $-2, %rdx - LONG $0x270ffe81; WORD $0x0000 // cmpl $9999, %esi - WORD $0xc689 // movl %eax, %esi - LONG $0xffd1870f; WORD $0xffff // ja LBB36_62, $-47(%rip) +LBB32_65: + WORD $0xda89 // movl %ebx, %edx + LONG $0x1fd26948; WORD $0xeb85; BYTE $0x51 // imulq $1374389535, %rdx, %rdx + LONG $0x25eac148 // shrq $37, %rdx + WORD $0xc26b; BYTE $0x64 // imull $100, %edx, %eax + WORD $0xde89 // movl %ebx, %esi + WORD $0xc629 // subl %eax, %esi + LONG $0x04b70f41; BYTE $0x73 // movzwl (%r11,%rsi,2), %eax + LONG $0xff418966 // movw %ax, $-1(%rcx) + LONG $0xfec18348 // addq $-2, %rcx + LONG $0x270ffb81; WORD $0x0000 // cmpl $9999, %ebx + WORD $0xd389 // movl %edx, %ebx + LONG $0xffd1870f; WORD $0xffff // ja LBB32_65, $-47(%rip) -LBB36_63: - LONG $0x01578d49 // leaq $1(%r15), %rdx - WORD $0xf883; BYTE $0x0a // cmpl $10, %eax - LONG $0x001f820f; WORD $0x0000 // jb LBB36_65, $31(%rip) - WORD $0xc689 // movl %eax, %esi - LONG $0xdb3d8d48; WORD $0x0041; BYTE $0x00 // leaq $16859(%rip), %rdi /* _Digits(%rip) */ - LONG $0x7704b60f // movzbl (%rdi,%rsi,2), %eax - LONG $0x775cb60f; BYTE $0x01 // movzbl $1(%rdi,%rsi,2), %ebx - LONG $0x01478841 // movb %al, $1(%r15) - LONG $0x025f8841 // movb %bl, $2(%r15) - LONG $0x000004e9; BYTE $0x00 // jmp LBB36_66, $4(%rip) - -LBB36_65: - WORD $0x3004 // addb $48, %al - WORD $0x0288 // movb %al, (%rdx) - -LBB36_66: - WORD $0x294d; BYTE $0xc1 // subq %r8, %r9 - WORD $0x014d; BYTE $0xe9 // addq %r13, %r9 - LONG $0x000001be; BYTE $0x00 // movl $1, %esi - WORD $0x294c; BYTE $0xc6 // subq %r8, %rsi - WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 +LBB32_66: + LONG $0x01708d49 // leaq $1(%r8), %rsi + WORD $0xfa83; BYTE $0x0a // cmpl $10, %edx + LONG $0x001d820f; WORD $0x0000 // jb LBB32_68, $29(%rip) + WORD $0xd089 // movl %edx, %eax + LONG $0x9b0d8d48; WORD $0x003d; BYTE $0x00 // leaq $15771(%rip), %rcx /* _Digits(%rip) */ + WORD $0x148a; BYTE $0x41 // movb (%rcx,%rax,2), %dl + LONG $0x0141448a // movb $1(%rcx,%rax,2), %al + LONG $0x01508841 // movb %dl, $1(%r8) + LONG $0x02408841 // movb %al, $2(%r8) + LONG $0x000005e9; BYTE $0x00 // jmp LBB32_69, $5(%rip) -LBB36_67: - WORD $0xff48; BYTE $0xce // decq %rsi - LONG $0x093c8041; BYTE $0x30 // cmpb $48, (%r9,%rcx) - LONG $0xff498d4d // leaq $-1(%r9), %r9 - LONG $0xffee840f; WORD $0xffff // je LBB36_67, $-18(%rip) - WORD $0x8841; BYTE $0x07 // movb %al, (%r15) - WORD $0x0148; BYTE $0xce // addq %rcx, %rsi - LONG $0x02fe8348 // cmpq $2, %rsi - LONG $0x00458c0f; WORD $0x0000 // jl LBB36_72, $69(%rip) - LONG $0x09048d49 // leaq (%r9,%rcx), %rax - LONG $0x02c08348 // addq $2, %rax - WORD $0x02c6; BYTE $0x2e // movb $46, (%rdx) - WORD $0x00c6; BYTE $0x65 // movb $101, (%rax) - WORD $0x8545; BYTE $0xd2 // testl %r10d, %r10d - LONG $0x00418e0f; WORD $0x0000 // jle LBB36_73, $65(%rip) +LBB32_68: + WORD $0xc280; BYTE $0x30 // addb $48, %dl + WORD $0x1688 // movb %dl, (%rsi) -LBB36_70: - WORD $0xff41; BYTE $0xca // decl %r10d - LONG $0x2b0140c6 // movb $43, $1(%rax) - WORD $0x8944; BYTE $0xd1 // movl %r10d, %ecx - WORD $0xf983; BYTE $0x0a // cmpl $10, %ecx - LONG $0x0043820f; WORD $0x0000 // jb LBB36_74, $67(%rip) - -LBB36_71: - WORD $0x6348; BYTE $0xc9 // movslq %ecx, %rcx - LONG $0x5a158d48; WORD $0x0041; BYTE $0x00 // leaq $16730(%rip), %rdx /* _Digits(%rip) */ - LONG $0x4a0cb70f // movzwl (%rdx,%rcx,2), %ecx - LONG $0x02488966 // movw %cx, $2(%rax) - LONG $0x04c08348 // addq $4, %rax - LONG $0x00097ae9; BYTE $0x00 // jmp LBB36_92, $2426(%rip) +LBB32_69: + WORD $0x294d; BYTE $0xce // subq %r9, %r14 + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 -LBB36_72: - LONG $0x09048d49 // leaq (%r9,%rcx), %rax - WORD $0xff48; BYTE $0xc0 // incq %rax - WORD $0x00c6; BYTE $0x65 // movb $101, (%rax) +LBB32_70: + LONG $0xff7e8041; BYTE $0x30 // cmpb $48, $-1(%r14) + LONG $0xff768d4d // leaq $-1(%r14), %r14 + LONG $0xfff1840f; WORD $0xffff // je LBB32_70, $-15(%rip) + WORD $0x8841; BYTE $0x10 // movb %dl, (%r8) + LONG $0x01468d49 // leaq $1(%r14), %rax + WORD $0x8948; BYTE $0xc1 // movq %rax, %rcx + WORD $0x2948; BYTE $0xf1 // subq %rsi, %rcx + LONG $0x02f98348 // cmpq $2, %rcx + LONG $0x00068c0f; WORD $0x0000 // jl LBB32_73, $6(%rip) + WORD $0x06c6; BYTE $0x2e // movb $46, (%rsi) + WORD $0x8949; BYTE $0xc6 // movq %rax, %r14 + +LBB32_73: + LONG $0x6506c641 // movb $101, (%r14) + LONG $0xff428d41 // leal $-1(%r10), %eax WORD $0x8545; BYTE $0xd2 // testl %r10d, %r10d - LONG $0xffbf8f0f; WORD $0xffff // jg LBB36_70, $-65(%rip) - -LBB36_73: - LONG $0x2d0140c6 // movb $45, $1(%rax) - LONG $0x000001b9; BYTE $0x00 // movl $1, %ecx - WORD $0x2944; BYTE $0xd1 // subl %r10d, %ecx - WORD $0xf983; BYTE $0x0a // cmpl $10, %ecx - LONG $0xffbd830f; WORD $0xffff // jae LBB36_71, $-67(%rip) - -LBB36_74: - WORD $0xc180; BYTE $0x30 // addb $48, %cl - WORD $0x4888; BYTE $0x02 // movb %cl, $2(%rax) - LONG $0x03c08348 // addq $3, %rax - LONG $0x000943e9; BYTE $0x00 // jmp LBB36_92, $2371(%rip) - -LBB36_33: - WORD $0xd341; BYTE $0xef // shrl %cl, %r15d - LONG $0xa0ff8141; WORD $0x0186; BYTE $0x00 // cmpl $100000, %r15d - LONG $0x01a8820f; WORD $0x0000 // jb LBB36_50, $424(%rip) - LONG $0x80ff8141; WORD $0x9896; BYTE $0x00 // cmpl $10000000, %r15d - LONG $0x000008b8; BYTE $0x00 // movl $8, %eax - LONG $0x00d88348 // sbbq $0, %rax - LONG $0x40ff8141; WORD $0x0f42; BYTE $0x00 // cmpl $1000000, %r15d - LONG $0x000006b9; BYTE $0x00 // movl $6, %ecx - LONG $0xc8430f48 // cmovaeq %rax, %rcx - WORD $0x014c; BYTE $0xe9 // addq %r13, %rcx + LONG $0x01228e0f; WORD $0x0000 // jle LBB32_76, $290(%rip) + LONG $0x0146c641; BYTE $0x2b // movb $43, $1(%r14) + WORD $0xf883; BYTE $0x0a // cmpl $10, %eax + LONG $0x01248c0f; WORD $0x0000 // jl LBB32_77, $292(%rip) -LBB36_35: - WORD $0x8944; BYTE $0xf8 // movl %r15d, %eax +LBB32_75: + WORD $0x9848 // cltq + LONG $0x1c0d8d48; WORD $0x003d; BYTE $0x00 // leaq $15644(%rip), %rcx /* _Digits(%rip) */ + LONG $0x4104b70f // movzwl (%rcx,%rax,2), %eax + LONG $0x46894166; BYTE $0x02 // movw %ax, $2(%r14) + LONG $0x04c68349 // addq $4, %r14 + WORD $0x894d; BYTE $0xf0 // movq %r14, %r8 + LONG $0x000889e9; BYTE $0x00 // jmp LBB32_136, $2185(%rip) + +LBB32_32: + WORD $0xeed3 // shrl %cl, %esi + LONG $0x86a0fe81; WORD $0x0001 // cmpl $100000, %esi + LONG $0x01f1820f; WORD $0x0000 // jb LBB32_52, $497(%rip) + LONG $0x000006b8; BYTE $0x00 // movl $6, %eax + LONG $0x4240fe81; WORD $0x000f // cmpl $1000000, %esi + LONG $0x0020820f; WORD $0x0000 // jb LBB32_36, $32(%rip) + LONG $0x000007b8; BYTE $0x00 // movl $7, %eax + LONG $0x9680fe81; WORD $0x0098 // cmpl $10000000, %esi + LONG $0x000f820f; WORD $0x0000 // jb LBB32_36, $15(%rip) + LONG $0xe100fe81; WORD $0x05f5 // cmpl $100000000, %esi + LONG $0x000009b8; BYTE $0x00 // movl $9, %eax + LONG $0x00d88348 // sbbq $0, %rax + +LBB32_36: + WORD $0x014c; BYTE $0xc0 // addq %r8, %rax + +LBB32_37: + WORD $0xf189 // movl %esi, %ecx LONG $0xb71759ba; BYTE $0xd1 // movl $3518437209, %edx - LONG $0xd0af0f48 // imulq %rax, %rdx + LONG $0xd1af0f48 // imulq %rcx, %rdx LONG $0x2deac148 // shrq $45, %rdx - LONG $0xd8f0c269; WORD $0xffff // imull $-10000, %edx, %eax - WORD $0x0144; BYTE $0xf8 // addl %r15d, %eax - LONG $0x1ff06948; WORD $0xeb85; BYTE $0x51 // imulq $1374389535, %rax, %rsi + LONG $0xd8f0ca69; WORD $0xffff // imull $-10000, %edx, %ecx + WORD $0xf101 // addl %esi, %ecx + LONG $0x1ff16948; WORD $0xeb85; BYTE $0x51 // imulq $1374389535, %rcx, %rsi LONG $0x25eec148 // shrq $37, %rsi WORD $0xde6b; BYTE $0x64 // imull $100, %esi, %ebx - WORD $0xd829 // subl %ebx, %eax - LONG $0xaf1d8d48; WORD $0x0040; BYTE $0x00 // leaq $16559(%rip), %rbx /* _Digits(%rip) */ - LONG $0x4304b70f // movzwl (%rbx,%rax,2), %eax - LONG $0xfe418966 // movw %ax, $-2(%rcx) - LONG $0x7304b70f // movzwl (%rbx,%rsi,2), %eax - LONG $0xfc418966 // movw %ax, $-4(%rcx) - WORD $0x8948; BYTE $0xc8 // movq %rcx, %rax - LONG $0xfcc18348 // addq $-4, %rcx - WORD $0x8941; BYTE $0xd7 // movl %edx, %r15d - LONG $0x64ff8341 // cmpl $100, %r15d - LONG $0x0171830f; WORD $0x0000 // jae LBB36_54, $369(%rip) - LONG $0x0001a8e9; BYTE $0x00 // jmp LBB36_56, $424(%rip) - -LBB36_36: - WORD $0x8545; BYTE $0xd2 // testl %r10d, %r10d - LONG $0x04dc8f0f; WORD $0x0000 // jg LBB36_102, $1244(%rip) - LONG $0x07c74166; WORD $0x2e30 // movw $11824, (%r15) - LONG $0x02c78349 // addq $2, %r15 - WORD $0x8545; BYTE $0xd2 // testl %r10d, %r10d - LONG $0x04c9890f; WORD $0x0000 // jns LBB36_102, $1225(%rip) - WORD $0x8945; BYTE $0xe6 // movl %r12d, %r14d - WORD $0xf741; BYTE $0xd6 // notl %r14d - WORD $0x2945; BYTE $0xde // subl %r11d, %r14d - WORD $0xc931 // xorl %ecx, %ecx - LONG $0x7ffe8341 // cmpl $127, %r14d - LONG $0x049d820f; WORD $0x0000 // jb LBB36_100, $1181(%rip) - WORD $0x894c; BYTE $0xfb // movq %r15, %rbx - WORD $0x894c; BYTE $0xef // movq %r13, %rdi - WORD $0xff49; BYTE $0xc6 // incq %r14 - WORD $0x894c; BYTE $0xf1 // movq %r14, %rcx - LONG $0x80e18348 // andq $-128, %rcx - LONG $0x80518d48 // leaq $-128(%rcx), %rdx - WORD $0x8949; BYTE $0xd5 // movq %rdx, %r13 - LONG $0x07edc149 // shrq $7, %r13 - WORD $0xff49; BYTE $0xc5 // incq %r13 - WORD $0x8945; BYTE $0xef // movl %r13d, %r15d - LONG $0x03e78341 // andl $3, %r15d - LONG $0x80fa8148; WORD $0x0001; BYTE $0x00 // cmpq $384, %rdx - LONG $0x036a830f; WORD $0x0000 // jae LBB36_94, $874(%rip) - WORD $0xd231 // xorl %edx, %edx - LONG $0x00040de9; BYTE $0x00 // jmp LBB36_96, $1037(%rip) + WORD $0xd929 // subl %ebx, %ecx + LONG $0x971d8d48; WORD $0x003c; BYTE $0x00 // leaq $15511(%rip), %rbx /* _Digits(%rip) */ + LONG $0x4b0cb70f // movzwl (%rbx,%rcx,2), %ecx + LONG $0xfe488966 // movw %cx, $-2(%rax) + LONG $0x730cb70f // movzwl (%rbx,%rsi,2), %ecx + LONG $0xfc488966 // movw %cx, $-4(%rax) + WORD $0x8949; BYTE $0xc1 // movq %rax, %r9 + LONG $0xfcc08348 // addq $-4, %rax + WORD $0xd689 // movl %edx, %esi + WORD $0xfe83; BYTE $0x64 // cmpl $100, %esi + LONG $0x01ac830f; WORD $0x0000 // jae LBB32_56, $428(%rip) + LONG $0x0001efe9; BYTE $0x00 // jmp LBB32_58, $495(%rip) -LBB36_41: - WORD $0x8948; BYTE $0xca // movq %rcx, %rdx - WORD $0x8945; BYTE $0xd3 // movl %r10d, %r11d - WORD $0xf883; BYTE $0x64 // cmpl $100, %eax - LONG $0xfdac820f; WORD $0xffff // jb LBB36_30, $-596(%rip) +LBB32_38: + WORD $0x8545; BYTE $0xd2 // testl %r10d, %r10d + LONG $0x04878f0f; WORD $0x0000 // jg LBB32_96, $1159(%rip) + LONG $0x00c74166; WORD $0x2e30 // movw $11824, (%r8) + LONG $0x02c08349 // addq $2, %r8 + WORD $0x8545; BYTE $0xd2 // testl %r10d, %r10d + LONG $0x0474890f; WORD $0x0000 // jns LBB32_96, $1140(%rip) + WORD $0xd6f7 // notl %esi + WORD $0x2944; BYTE $0xde // subl %r11d, %esi + WORD $0x3145; BYTE $0xff // xorl %r15d, %r15d + WORD $0xfe83; BYTE $0x7f // cmpl $127, %esi + LONG $0x043e820f; WORD $0x0000 // jb LBB32_94, $1086(%rip) + WORD $0xff48; BYTE $0xc6 // incq %rsi + WORD $0x8949; BYTE $0xf7 // movq %rsi, %r15 + LONG $0x80e78349 // andq $-128, %r15 + LONG $0x80478d49 // leaq $-128(%r15), %rax + WORD $0x8949; BYTE $0xc6 // movq %rax, %r14 + LONG $0x07eec149 // shrq $7, %r14 + WORD $0xff49; BYTE $0xc6 // incq %r14 + WORD $0x8945; BYTE $0xf3 // movl %r14d, %r11d + LONG $0x03e38341 // andl $3, %r11d + LONG $0x01803d48; WORD $0x0000 // cmpq $384, %rax + LONG $0x0321830f; WORD $0x0000 // jae LBB32_88, $801(%rip) + WORD $0xdb31 // xorl %ebx, %ebx + LONG $0x0003c4e9; BYTE $0x00 // jmp LBB32_90, $964(%rip) -LBB36_42: - WORD $0xff48; BYTE $0xca // decq %rdx - LONG $0x03358d4c; WORD $0x0040; BYTE $0x00 // leaq $16387(%rip), %r14 /* _Digits(%rip) */ - WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 +LBB32_76: + LONG $0x0146c641; BYTE $0x2d // movb $45, $1(%r14) + WORD $0xd8f7 // negl %eax + WORD $0xf883; BYTE $0x0a // cmpl $10, %eax + LONG $0xfedc8d0f; WORD $0xffff // jge LBB32_75, $-292(%rip) -LBB36_43: - WORD $0xc689 // movl %eax, %esi - LONG $0x1ff66948; WORD $0xeb85; BYTE $0x51 // imulq $1374389535, %rsi, %rsi - LONG $0x25eec148 // shrq $37, %rsi - WORD $0xfe6b; BYTE $0x64 // imull $100, %esi, %edi - WORD $0xc389 // movl %eax, %ebx - WORD $0xfb29 // subl %edi, %ebx - LONG $0x3cb70f41; BYTE $0x5e // movzwl (%r14,%rbx,2), %edi - LONG $0xff7a8966 // movw %di, $-1(%rdx) - LONG $0xfec28348 // addq $-2, %rdx - LONG $0x00270f3d; BYTE $0x00 // cmpl $9999, %eax - WORD $0xf089 // movl %esi, %eax - LONG $0xffd2870f; WORD $0xffff // ja LBB36_43, $-46(%rip) +LBB32_77: + WORD $0x3004 // addb $48, %al + LONG $0x02468841 // movb %al, $2(%r14) + LONG $0x03c68349 // addq $3, %r14 + WORD $0x894d; BYTE $0xf0 // movq %r14, %r8 + LONG $0x000771e9; BYTE $0x00 // jmp LBB32_136, $1905(%rip) -LBB36_44: - WORD $0xfe83; BYTE $0x0a // cmpl $10, %esi - LONG $0x0022820f; WORD $0x0000 // jb LBB36_46, $34(%rip) - WORD $0xf089 // movl %esi, %eax - LONG $0xc0158d48; WORD $0x003f; BYTE $0x00 // leaq $16320(%rip), %rdx /* _Digits(%rip) */ - LONG $0x4204b70f // movzwl (%rdx,%rax,2), %eax - LONG $0x07894166 // movw %ax, (%r15) - WORD $0x014d; BYTE $0xdf // addq %r11, %r15 - WORD $0x3945; BYTE $0xd4 // cmpl %r10d, %r12d - LONG $0x0018820f; WORD $0x0000 // jb LBB36_47, $24(%rip) - LONG $0x0002e6e9; BYTE $0x00 // jmp LBB36_91, $742(%rip) - -LBB36_46: - LONG $0x30c68040 // addb $48, %sil - WORD $0x8841; BYTE $0x37 // movb %sil, (%r15) - WORD $0x014d; BYTE $0xdf // addq %r11, %r15 - WORD $0x3945; BYTE $0xd4 // cmpl %r10d, %r12d - LONG $0x02d3830f; WORD $0x0000 // jae LBB36_91, $723(%rip) - -LBB36_47: - LONG $0x29048d4b // leaq (%r9,%r13), %rax - LONG $0x00148d49 // leaq (%r8,%rax), %rdx - WORD $0xff48; BYTE $0xc2 // incq %rdx - WORD $0x0149; BYTE $0xc3 // addq %rax, %r11 - WORD $0x394c; BYTE $0xda // cmpq %r11, %rdx - LONG $0xda470f4c // cmovaq %rdx, %r11 - WORD $0x014c; BYTE $0xc0 // addq %r8, %rax - WORD $0x2949; BYTE $0xc3 // subq %rax, %r11 - LONG $0x10fb8349 // cmpq $16, %r11 - LONG $0x029f820f; WORD $0x0000 // jb LBB36_90, $671(%rip) +LBB32_43: + WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax + LONG $0x64fd8341 // cmpl $100, %r13d + LONG $0xfdb7820f; WORD $0xffff // jb LBB32_29, $-585(%rip) + +LBB32_44: + WORD $0xff48; BYTE $0xc8 // decq %rax + LONG $0xd81d8d4c; WORD $0x003b; BYTE $0x00 // leaq $15320(%rip), %r11 /* _Digits(%rip) */ + QUAD $0x9090909090909090 // .p2align 4, 0x90 + +LBB32_45: + WORD $0x8944; BYTE $0xe9 // movl %r13d, %ecx + LONG $0x1fc96948; WORD $0xeb85; BYTE $0x51 // imulq $1374389535, %rcx, %rcx + LONG $0x25e9c148 // shrq $37, %rcx + WORD $0xd96b; BYTE $0x64 // imull $100, %ecx, %ebx + WORD $0x8944; BYTE $0xea // movl %r13d, %edx + WORD $0xda29 // subl %ebx, %edx + LONG $0x14b70f41; BYTE $0x53 // movzwl (%r11,%rdx,2), %edx + LONG $0xff508966 // movw %dx, $-1(%rax) + LONG $0xfec08348 // addq $-2, %rax + LONG $0x0ffd8141; WORD $0x0027; BYTE $0x00 // cmpl $9999, %r13d + WORD $0x8941; BYTE $0xcd // movl %ecx, %r13d + LONG $0xffcd870f; WORD $0xffff // ja LBB32_45, $-51(%rip) + +LBB32_46: + WORD $0x6349; BYTE $0xc2 // movslq %r10d, %rax + WORD $0xf983; BYTE $0x0a // cmpl $10, %ecx + LONG $0x0022820f; WORD $0x0000 // jb LBB32_48, $34(%rip) + WORD $0xc989 // movl %ecx, %ecx + LONG $0x88158d48; WORD $0x003b; BYTE $0x00 // leaq $15240(%rip), %rdx /* _Digits(%rip) */ + LONG $0x4a0cb70f // movzwl (%rdx,%rcx,2), %ecx + LONG $0x08894166 // movw %cx, (%r8) + WORD $0x0149; BYTE $0xc0 // addq %rax, %r8 + WORD $0x3949; BYTE $0xc4 // cmpq %rax, %r12 + LONG $0x00178c0f; WORD $0x0000 // jl LBB32_49, $23(%rip) + LONG $0x0006f1e9; BYTE $0x00 // jmp LBB32_136, $1777(%rip) + +LBB32_48: + WORD $0xc180; BYTE $0x30 // addb $48, %cl + WORD $0x8841; BYTE $0x08 // movb %cl, (%r8) + WORD $0x0149; BYTE $0xc0 // addq %rax, %r8 + WORD $0x3949; BYTE $0xc4 // cmpq %rax, %r12 + LONG $0x06df8d0f; WORD $0x0000 // jge LBB32_136, $1759(%rip) + +LBB32_49: + LONG $0x21048d4b // leaq (%r9,%r12), %rax + LONG $0x075c8d4c; BYTE $0x01 // leaq $1(%rdi,%rax), %r11 + WORD $0x394d; BYTE $0xc3 // cmpq %r8, %r11 + LONG $0xd8460f4d // cmovbeq %r8, %r11 + LONG $0x0f0c8d4a // leaq (%rdi,%r9), %rcx + WORD $0x014c; BYTE $0xe1 // addq %r12, %rcx + WORD $0x2949; BYTE $0xcb // subq %rcx, %r11 LONG $0x80fb8149; WORD $0x0000; BYTE $0x00 // cmpq $128, %r11 - LONG $0x00cf830f; WORD $0x0000 // jae LBB36_75, $207(%rip) - WORD $0x3145; BYTE $0xd2 // xorl %r10d, %r10d - LONG $0x000211e9; BYTE $0x00 // jmp LBB36_84, $529(%rip) + LONG $0x0206820f; WORD $0x0000 // jb LBB32_85, $518(%rip) + WORD $0x894d; BYTE $0xda // movq %r11, %r10 + LONG $0x80e28349 // andq $-128, %r10 + LONG $0x804a8d49 // leaq $-128(%r10), %rcx + WORD $0x8948; BYTE $0xcb // movq %rcx, %rbx + LONG $0x07ebc148 // shrq $7, %rbx + WORD $0xff48; BYTE $0xc3 // incq %rbx + WORD $0xda89 // movl %ebx, %edx + WORD $0xe283; BYTE $0x03 // andl $3, %edx + LONG $0x80f98148; WORD $0x0001; BYTE $0x00 // cmpq $384, %rcx + LONG $0x00d7830f; WORD $0x0000 // jae LBB32_78, $215(%rip) + WORD $0xc031 // xorl %eax, %eax + LONG $0x000188e9; BYTE $0x00 // jmp LBB32_80, $392(%rip) -LBB36_50: - LONG $0x000001b8; BYTE $0x00 // movl $1, %eax - LONG $0x0aff8341 // cmpl $10, %r15d - LONG $0x0021820f; WORD $0x0000 // jb LBB36_53, $33(%rip) - LONG $0x000002b8; BYTE $0x00 // movl $2, %eax - LONG $0x64ff8341 // cmpl $100, %r15d - LONG $0x0012820f; WORD $0x0000 // jb LBB36_53, $18(%rip) - LONG $0x000003b8; BYTE $0x00 // movl $3, %eax - LONG $0xe7ff8141; WORD $0x0003; BYTE $0x00 // cmpl $999, %r15d - LONG $0x022b870f; WORD $0x0000 // ja LBB36_87, $555(%rip) - -LBB36_53: - WORD $0x014c; BYTE $0xe8 // addq %r13, %rax - WORD $0x8948; BYTE $0xc1 // movq %rax, %rcx - LONG $0x64ff8341 // cmpl $100, %r15d - LONG $0x003c820f; WORD $0x0000 // jb LBB36_56, $60(%rip) +LBB32_52: + LONG $0x0001b941; WORD $0x0000 // movl $1, %r9d + WORD $0xfe83; BYTE $0x0a // cmpl $10, %esi + LONG $0x0021820f; WORD $0x0000 // jb LBB32_55, $33(%rip) + LONG $0x0002b941; WORD $0x0000 // movl $2, %r9d + WORD $0xfe83; BYTE $0x64 // cmpl $100, %esi + LONG $0x0012820f; WORD $0x0000 // jb LBB32_55, $18(%rip) + LONG $0x0003b941; WORD $0x0000 // movl $3, %r9d + LONG $0x03e8fe81; WORD $0x0000 // cmpl $1000, %esi + LONG $0x01bc830f; WORD $0x0000 // jae LBB32_86, $444(%rip) -LBB36_54: - WORD $0xff48; BYTE $0xc9 // decq %rcx - LONG $0x10058d4c; WORD $0x003f; BYTE $0x00 // leaq $16144(%rip), %r8 /* _Digits(%rip) */ +LBB32_55: + WORD $0x014d; BYTE $0xc1 // addq %r8, %r9 + WORD $0x894c; BYTE $0xc8 // movq %r9, %rax + WORD $0xfe83; BYTE $0x64 // cmpl $100, %esi + LONG $0x0048820f; WORD $0x0000 // jb LBB32_58, $72(%rip) - // .p2align 4, 0x90 -LBB36_55: - WORD $0x8944; BYTE $0xfb // movl %r15d, %ebx - WORD $0x8944; BYTE $0xfe // movl %r15d, %esi - LONG $0x1ffe694c; WORD $0xeb85; BYTE $0x51 // imulq $1374389535, %rsi, %r15 - LONG $0x25efc149 // shrq $37, %r15 - LONG $0x64f76b41 // imull $100, %r15d, %esi +LBB32_56: + WORD $0xff48; BYTE $0xc8 // decq %rax + LONG $0xbf158d4c; WORD $0x003a; BYTE $0x00 // leaq $15039(%rip), %r10 /* _Digits(%rip) */ + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB32_57: + WORD $0xf389 // movl %esi, %ebx + WORD $0xf689 // movl %esi, %esi + LONG $0x1ff66948; WORD $0xeb85; BYTE $0x51 // imulq $1374389535, %rsi, %rsi + LONG $0x25eec148 // shrq $37, %rsi + WORD $0xce6b; BYTE $0x64 // imull $100, %esi, %ecx WORD $0xda89 // movl %ebx, %edx - WORD $0xf229 // subl %esi, %edx - LONG $0x14b70f41; BYTE $0x50 // movzwl (%r8,%rdx,2), %edx - LONG $0xff518966 // movw %dx, $-1(%rcx) - LONG $0xfec18348 // addq $-2, %rcx + WORD $0xca29 // subl %ecx, %edx + LONG $0x0cb70f41; BYTE $0x52 // movzwl (%r10,%rdx,2), %ecx + LONG $0xff488966 // movw %cx, $-1(%rax) + LONG $0xfec08348 // addq $-2, %rax LONG $0x270ffb81; WORD $0x0000 // cmpl $9999, %ebx - LONG $0xffce870f; WORD $0xffff // ja LBB36_55, $-50(%rip) + LONG $0xffd1870f; WORD $0xffff // ja LBB32_57, $-47(%rip) -LBB36_56: - LONG $0x0aff8341 // cmpl $10, %r15d - LONG $0x001a820f; WORD $0x0000 // jb LBB36_58, $26(%rip) - WORD $0x8944; BYTE $0xf9 // movl %r15d, %ecx - LONG $0xca158d48; WORD $0x003e; BYTE $0x00 // leaq $16074(%rip), %rdx /* _Digits(%rip) */ - LONG $0x4a0cb70f // movzwl (%rdx,%rcx,2), %ecx - LONG $0x4d894166; BYTE $0x00 // movw %cx, (%r13) - WORD $0xf829 // subl %edi, %eax - LONG $0x0006eee9; BYTE $0x00 // jmp LBB36_93, $1774(%rip) +LBB32_58: + WORD $0xfe83; BYTE $0x0a // cmpl $10, %esi + LONG $0x0016820f; WORD $0x0000 // jb LBB32_60, $22(%rip) + WORD $0xf089 // movl %esi, %eax + LONG $0x6f0d8d48; WORD $0x003a; BYTE $0x00 // leaq $14959(%rip), %rcx /* _Digits(%rip) */ + LONG $0x4104b70f // movzwl (%rcx,%rax,2), %eax + LONG $0x00894166 // movw %ax, (%r8) + LONG $0x000007e9; BYTE $0x00 // jmp LBB32_61, $7(%rip) -LBB36_58: - LONG $0x30c78041 // addb $48, %r15b - LONG $0x007d8845 // movb %r15b, (%r13) - WORD $0xf829 // subl %edi, %eax - LONG $0x0006dfe9; BYTE $0x00 // jmp LBB36_93, $1759(%rip) +LBB32_60: + LONG $0x30c68040 // addb $48, %sil + WORD $0x8841; BYTE $0x30 // movb %sil, (%r8) -LBB36_59: - LONG $0x0004b841; WORD $0x0000 // movl $4, %r8d - LONG $0xfcc28348 // addq $-4, %rdx - WORD $0xfe83; BYTE $0x64 // cmpl $100, %esi - LONG $0xfbc5820f; WORD $0xffff // jb LBB36_32, $-1083(%rip) - LONG $0xfffc66e9; BYTE $0xff // jmp LBB36_61, $-922(%rip) +LBB32_61: + WORD $0x2941; BYTE $0xf9 // subl %edi, %r9d + WORD $0x8945; BYTE $0xc8 // movl %r9d, %r8d + LONG $0x0005d5e9; BYTE $0x00 // jmp LBB32_137, $1493(%rip) -LBB36_75: - WORD $0x894d; BYTE $0xda // movq %r11, %r10 - LONG $0x80e28349 // andq $-128, %r10 - LONG $0x80428d49 // leaq $-128(%r10), %rax - WORD $0x8948; BYTE $0xc2 // movq %rax, %rdx - LONG $0x07eac148 // shrq $7, %rdx - WORD $0xff48; BYTE $0xc2 // incq %rdx - WORD $0x8941; BYTE $0xd6 // movl %edx, %r14d - LONG $0x03e68341 // andl $3, %r14d - LONG $0x01803d48; WORD $0x0000 // cmpq $384, %rax - LONG $0x0007830f; WORD $0x0000 // jae LBB36_77, $7(%rip) - WORD $0xf631 // xorl %esi, %esi - LONG $0x0000b5e9; BYTE $0x00 // jmp LBB36_79, $181(%rip) - -LBB36_77: - LONG $0xfce28348 // andq $-4, %rdx - LONG $0x01048d4b // leaq (%r9,%r8), %rax - WORD $0x014c; BYTE $0xe8 // addq %r13, %rax - LONG $0x01e00548; WORD $0x0000 // addq $480, %rax - WORD $0xf631 // xorl %esi, %esi - QUAD $0xfffff849056ffdc5 // vmovdqa $-1975(%rip), %ymm0 /* LCPI36_0(%rip) */ - QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90 +LBB32_62: + LONG $0x0004b941; WORD $0x0000 // movl $4, %r9d + LONG $0xfc4e8d49 // leaq $-4(%r14), %rcx + WORD $0xfb83; BYTE $0x64 // cmpl $100, %ebx + LONG $0xfb9d820f; WORD $0xffff // jb LBB32_31, $-1123(%rip) + LONG $0xfffc43e9; BYTE $0xff // jmp LBB32_64, $-957(%rip) -LBB36_78: - QUAD $0xfffe2030847ffec5; BYTE $0xff // vmovdqu %ymm0, $-480(%rax,%rsi) - QUAD $0xfffe4030847ffec5; BYTE $0xff // vmovdqu %ymm0, $-448(%rax,%rsi) - QUAD $0xfffe6030847ffec5; BYTE $0xff // vmovdqu %ymm0, $-416(%rax,%rsi) - QUAD $0xfffe8030847ffec5; BYTE $0xff // vmovdqu %ymm0, $-384(%rax,%rsi) - QUAD $0xfffea030847ffec5; BYTE $0xff // vmovdqu %ymm0, $-352(%rax,%rsi) - QUAD $0xfffec030847ffec5; BYTE $0xff // vmovdqu %ymm0, $-320(%rax,%rsi) - QUAD $0xfffee030847ffec5; BYTE $0xff // vmovdqu %ymm0, $-288(%rax,%rsi) - QUAD $0xffff0030847ffec5; BYTE $0xff // vmovdqu %ymm0, $-256(%rax,%rsi) - QUAD $0xffff2030847ffec5; BYTE $0xff // vmovdqu %ymm0, $-224(%rax,%rsi) - QUAD $0xffff4030847ffec5; BYTE $0xff // vmovdqu %ymm0, $-192(%rax,%rsi) - QUAD $0xffff6030847ffec5; BYTE $0xff // vmovdqu %ymm0, $-160(%rax,%rsi) - LONG $0x447ffec5; WORD $0x8030 // vmovdqu %ymm0, $-128(%rax,%rsi) - LONG $0x447ffec5; WORD $0xa030 // vmovdqu %ymm0, $-96(%rax,%rsi) - LONG $0x447ffec5; WORD $0xc030 // vmovdqu %ymm0, $-64(%rax,%rsi) - LONG $0x447ffec5; WORD $0xe030 // vmovdqu %ymm0, $-32(%rax,%rsi) - LONG $0x047ffec5; BYTE $0x30 // vmovdqu %ymm0, (%rax,%rsi) - LONG $0x00c68148; WORD $0x0002; BYTE $0x00 // addq $512, %rsi - LONG $0xfcc28348 // addq $-4, %rdx - LONG $0xff6f850f; WORD $0xffff // jne LBB36_78, $-145(%rip) - -LBB36_79: - WORD $0x854d; BYTE $0xf6 // testq %r14, %r14 - LONG $0x004a840f; WORD $0x0000 // je LBB36_82, $74(%rip) - WORD $0x014c; BYTE $0xce // addq %r9, %rsi - WORD $0x014c; BYTE $0xc6 // addq %r8, %rsi - LONG $0x2e048d4a // leaq (%rsi,%r13), %rax - LONG $0x60c08348 // addq $96, %rax - LONG $0x07e6c149 // shlq $7, %r14 - WORD $0xd231 // xorl %edx, %edx - QUAD $0xfffff78a056ffdc5 // vmovdqa $-2166(%rip), %ymm0 /* LCPI36_0(%rip) */ - QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90 +LBB32_78: + QUAD $0x000001e0078c8d48 // leaq $480(%rdi,%rax), %rcx + LONG $0xfce38348 // andq $-4, %rbx + WORD $0xf748; BYTE $0xdb // negq %rbx + WORD $0xc031 // xorl %eax, %eax + QUAD $0xfffff87f056ffdc5 // vmovdqa $-1921(%rip), %ymm0 /* LCPI32_0(%rip) */ + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 -LBB36_81: - LONG $0x447ffec5; WORD $0xa010 // vmovdqu %ymm0, $-96(%rax,%rdx) - LONG $0x447ffec5; WORD $0xc010 // vmovdqu %ymm0, $-64(%rax,%rdx) - LONG $0x447ffec5; WORD $0xe010 // vmovdqu %ymm0, $-32(%rax,%rdx) - LONG $0x047ffec5; BYTE $0x10 // vmovdqu %ymm0, (%rax,%rdx) - LONG $0x80ea8348 // subq $-128, %rdx - WORD $0x3949; BYTE $0xd6 // cmpq %rdx, %r14 - LONG $0xffdc850f; WORD $0xffff // jne LBB36_81, $-36(%rip) +LBB32_79: + QUAD $0xfffe2001847ffec5; BYTE $0xff // vmovdqu %ymm0, $-480(%rcx,%rax) + QUAD $0xfffe4001847ffec5; BYTE $0xff // vmovdqu %ymm0, $-448(%rcx,%rax) + QUAD $0xfffe6001847ffec5; BYTE $0xff // vmovdqu %ymm0, $-416(%rcx,%rax) + QUAD $0xfffe8001847ffec5; BYTE $0xff // vmovdqu %ymm0, $-384(%rcx,%rax) + QUAD $0xfffea001847ffec5; BYTE $0xff // vmovdqu %ymm0, $-352(%rcx,%rax) + QUAD $0xfffec001847ffec5; BYTE $0xff // vmovdqu %ymm0, $-320(%rcx,%rax) + QUAD $0xfffee001847ffec5; BYTE $0xff // vmovdqu %ymm0, $-288(%rcx,%rax) + QUAD $0xffff0001847ffec5; BYTE $0xff // vmovdqu %ymm0, $-256(%rcx,%rax) + QUAD $0xffff2001847ffec5; BYTE $0xff // vmovdqu %ymm0, $-224(%rcx,%rax) + QUAD $0xffff4001847ffec5; BYTE $0xff // vmovdqu %ymm0, $-192(%rcx,%rax) + QUAD $0xffff6001847ffec5; BYTE $0xff // vmovdqu %ymm0, $-160(%rcx,%rax) + LONG $0x447ffec5; WORD $0x8001 // vmovdqu %ymm0, $-128(%rcx,%rax) + LONG $0x447ffec5; WORD $0xa001 // vmovdqu %ymm0, $-96(%rcx,%rax) + LONG $0x447ffec5; WORD $0xc001 // vmovdqu %ymm0, $-64(%rcx,%rax) + LONG $0x447ffec5; WORD $0xe001 // vmovdqu %ymm0, $-32(%rcx,%rax) + LONG $0x047ffec5; BYTE $0x01 // vmovdqu %ymm0, (%rcx,%rax) + LONG $0x02000548; WORD $0x0000 // addq $512, %rax + LONG $0x04c38348 // addq $4, %rbx + LONG $0xff70850f; WORD $0xffff // jne LBB32_79, $-144(%rip) -LBB36_82: - WORD $0x394d; BYTE $0xd3 // cmpq %r10, %r11 - LONG $0x0092840f; WORD $0x0000 // je LBB36_91, $146(%rip) - LONG $0x70c3f641 // testb $112, %r11b - LONG $0x0071840f; WORD $0x0000 // je LBB36_89, $113(%rip) +LBB32_80: + WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx + LONG $0x0037840f; WORD $0x0000 // je LBB32_83, $55(%rip) + WORD $0x014c; BYTE $0xc8 // addq %r9, %rax + WORD $0x014c; BYTE $0xe0 // addq %r12, %rax + LONG $0x07448d48; BYTE $0x60 // leaq $96(%rdi,%rax), %rax + WORD $0xf748; BYTE $0xda // negq %rdx + QUAD $0xfffff7c1056ffdc5 // vmovdqa $-2111(%rip), %ymm0 /* LCPI32_0(%rip) */ + BYTE $0x90 // .p2align 4, 0x90 -LBB36_84: - WORD $0x894c; BYTE $0xd8 // movq %r11, %rax - LONG $0xf0e08348 // andq $-16, %rax - WORD $0x0148; BYTE $0xc1 // addq %rax, %rcx - WORD $0x014d; BYTE $0xd1 // addq %r10, %r9 - WORD $0x014d; BYTE $0xc1 // addq %r8, %r9 - WORD $0x014d; BYTE $0xe9 // addq %r13, %r9 - WORD $0x8948; BYTE $0xc2 // movq %rax, %rdx - WORD $0x294c; BYTE $0xd2 // subq %r10, %rdx - WORD $0xf631 // xorl %esi, %esi - QUAD $0xfffff746056ff9c5 // vmovdqa $-2234(%rip), %xmm0 /* LCPI36_1(%rip) */ - LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 +LBB32_82: + LONG $0x407ffec5; BYTE $0xa0 // vmovdqu %ymm0, $-96(%rax) + LONG $0x407ffec5; BYTE $0xc0 // vmovdqu %ymm0, $-64(%rax) + LONG $0x407ffec5; BYTE $0xe0 // vmovdqu %ymm0, $-32(%rax) + LONG $0x007ffec5 // vmovdqu %ymm0, (%rax) + LONG $0x80e88348 // subq $-128, %rax + WORD $0xff48; BYTE $0xc2 // incq %rdx + LONG $0xffe0850f; WORD $0xffff // jne LBB32_82, $-32(%rip) -LBB36_85: - LONG $0x7f7ac1c4; WORD $0x3104 // vmovdqu %xmm0, (%r9,%rsi) - LONG $0x10c68348 // addq $16, %rsi - WORD $0x3948; BYTE $0xf2 // cmpq %rsi, %rdx - LONG $0xffed850f; WORD $0xffff // jne LBB36_85, $-19(%rip) - WORD $0x3949; BYTE $0xc3 // cmpq %rax, %r11 - LONG $0x0034850f; WORD $0x0000 // jne LBB36_90, $52(%rip) - LONG $0x00003ee9; BYTE $0x00 // jmp LBB36_91, $62(%rip) - -LBB36_87: - LONG $0x10ff8141; WORD $0x0027; BYTE $0x00 // cmpl $10000, %r15d - WORD $0x894c; BYTE $0xe9 // movq %r13, %rcx - LONG $0x00d98348 // sbbq $0, %rcx - LONG $0x05c18348 // addq $5, %rcx - LONG $0x10ff8141; WORD $0x0027; BYTE $0x00 // cmpl $10000, %r15d - LONG $0xfc01830f; WORD $0xffff // jae LBB36_35, $-1023(%rip) - WORD $0x8948; BYTE $0xc8 // movq %rcx, %rax - LONG $0xfffdbee9; BYTE $0xff // jmp LBB36_54, $-578(%rip) +LBB32_83: + WORD $0x394d; BYTE $0xda // cmpq %r11, %r10 + LONG $0x04b9840f; WORD $0x0000 // je LBB32_136, $1209(%rip) + WORD $0x014c; BYTE $0xd6 // addq %r10, %rsi + LONG $0x90909090 // .p2align 4, 0x90 -LBB36_89: - WORD $0x014c; BYTE $0xd1 // addq %r10, %rcx - LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 +LBB32_85: + WORD $0x06c6; BYTE $0x30 // movb $48, (%rsi) + WORD $0xff48; BYTE $0xc6 // incq %rsi + WORD $0x394c; BYTE $0xc6 // cmpq %r8, %rsi + LONG $0xfff1820f; WORD $0xffff // jb LBB32_85, $-15(%rip) + LONG $0x00049ee9; BYTE $0x00 // jmp LBB32_136, $1182(%rip) -LBB36_90: - WORD $0x01c6; BYTE $0x30 // movb $48, (%rcx) - WORD $0xff48; BYTE $0xc1 // incq %rcx - WORD $0x394c; BYTE $0xf9 // cmpq %r15, %rcx - LONG $0xfff1820f; WORD $0xffff // jb LBB36_90, $-15(%rip) +LBB32_86: + LONG $0x2710fe81; WORD $0x0000 // cmpl $10000, %esi + WORD $0x894c; BYTE $0xc0 // movq %r8, %rax + LONG $0x00d88348 // sbbq $0, %rax + LONG $0x05c08348 // addq $5, %rax + LONG $0x2710fe81; WORD $0x0000 // cmpl $10000, %esi + LONG $0xfc3a830f; WORD $0xffff // jae LBB32_37, $-966(%rip) + WORD $0x8949; BYTE $0xc1 // movq %rax, %r9 + LONG $0xfffe2ee9; BYTE $0xff // jmp LBB32_56, $-466(%rip) -LBB36_91: - WORD $0x894c; BYTE $0xf8 // movq %r15, %rax - LONG $0x0004eae9; BYTE $0x00 // jmp LBB36_92, $1258(%rip) +LBB32_88: + QUAD $0x000001e239848d49 // leaq $482(%r9,%rdi), %rax + LONG $0xfce68349 // andq $-4, %r14 + WORD $0xf749; BYTE $0xde // negq %r14 + WORD $0xdb31 // xorl %ebx, %ebx + QUAD $0xfffff73e056ffdc5 // vmovdqa $-2242(%rip), %ymm0 /* LCPI32_0(%rip) */ -LBB36_94: - LONG $0xfce58349 // andq $-4, %r13 - LONG $0x39348d49 // leaq (%r9,%rdi), %rsi - LONG $0xe2c68148; WORD $0x0001; BYTE $0x00 // addq $482, %rsi - WORD $0xd231 // xorl %edx, %edx - QUAD $0xfffff6a0056ffdc5 // vmovdqa $-2400(%rip), %ymm0 /* LCPI36_0(%rip) */ - -LBB36_95: - QUAD $0xfffe2016847ffec5; BYTE $0xff // vmovdqu %ymm0, $-480(%rsi,%rdx) - QUAD $0xfffe4016847ffec5; BYTE $0xff // vmovdqu %ymm0, $-448(%rsi,%rdx) - QUAD $0xfffe6016847ffec5; BYTE $0xff // vmovdqu %ymm0, $-416(%rsi,%rdx) - QUAD $0xfffe8016847ffec5; BYTE $0xff // vmovdqu %ymm0, $-384(%rsi,%rdx) - QUAD $0xfffea016847ffec5; BYTE $0xff // vmovdqu %ymm0, $-352(%rsi,%rdx) - QUAD $0xfffec016847ffec5; BYTE $0xff // vmovdqu %ymm0, $-320(%rsi,%rdx) - QUAD $0xfffee016847ffec5; BYTE $0xff // vmovdqu %ymm0, $-288(%rsi,%rdx) - QUAD $0xffff0016847ffec5; BYTE $0xff // vmovdqu %ymm0, $-256(%rsi,%rdx) - QUAD $0xffff2016847ffec5; BYTE $0xff // vmovdqu %ymm0, $-224(%rsi,%rdx) - QUAD $0xffff4016847ffec5; BYTE $0xff // vmovdqu %ymm0, $-192(%rsi,%rdx) - QUAD $0xffff6016847ffec5; BYTE $0xff // vmovdqu %ymm0, $-160(%rsi,%rdx) - LONG $0x447ffec5; WORD $0x8016 // vmovdqu %ymm0, $-128(%rsi,%rdx) - LONG $0x447ffec5; WORD $0xa016 // vmovdqu %ymm0, $-96(%rsi,%rdx) - LONG $0x447ffec5; WORD $0xc016 // vmovdqu %ymm0, $-64(%rsi,%rdx) - LONG $0x447ffec5; WORD $0xe016 // vmovdqu %ymm0, $-32(%rsi,%rdx) - LONG $0x047ffec5; BYTE $0x16 // vmovdqu %ymm0, (%rsi,%rdx) - LONG $0x00c28148; WORD $0x0002; BYTE $0x00 // addq $512, %rdx - LONG $0xfcc58349 // addq $-4, %r13 - LONG $0xff6f850f; WORD $0xffff // jne LBB36_95, $-145(%rip) +LBB32_89: + QUAD $0xfffe2018847ffec5; BYTE $0xff // vmovdqu %ymm0, $-480(%rax,%rbx) + QUAD $0xfffe4018847ffec5; BYTE $0xff // vmovdqu %ymm0, $-448(%rax,%rbx) + QUAD $0xfffe6018847ffec5; BYTE $0xff // vmovdqu %ymm0, $-416(%rax,%rbx) + QUAD $0xfffe8018847ffec5; BYTE $0xff // vmovdqu %ymm0, $-384(%rax,%rbx) + QUAD $0xfffea018847ffec5; BYTE $0xff // vmovdqu %ymm0, $-352(%rax,%rbx) + QUAD $0xfffec018847ffec5; BYTE $0xff // vmovdqu %ymm0, $-320(%rax,%rbx) + QUAD $0xfffee018847ffec5; BYTE $0xff // vmovdqu %ymm0, $-288(%rax,%rbx) + QUAD $0xffff0018847ffec5; BYTE $0xff // vmovdqu %ymm0, $-256(%rax,%rbx) + QUAD $0xffff2018847ffec5; BYTE $0xff // vmovdqu %ymm0, $-224(%rax,%rbx) + QUAD $0xffff4018847ffec5; BYTE $0xff // vmovdqu %ymm0, $-192(%rax,%rbx) + QUAD $0xffff6018847ffec5; BYTE $0xff // vmovdqu %ymm0, $-160(%rax,%rbx) + LONG $0x447ffec5; WORD $0x8018 // vmovdqu %ymm0, $-128(%rax,%rbx) + LONG $0x447ffec5; WORD $0xa018 // vmovdqu %ymm0, $-96(%rax,%rbx) + LONG $0x447ffec5; WORD $0xc018 // vmovdqu %ymm0, $-64(%rax,%rbx) + LONG $0x447ffec5; WORD $0xe018 // vmovdqu %ymm0, $-32(%rax,%rbx) + LONG $0x047ffec5; BYTE $0x18 // vmovdqu %ymm0, (%rax,%rbx) + LONG $0x00c38148; WORD $0x0002; BYTE $0x00 // addq $512, %rbx + LONG $0x04c68349 // addq $4, %r14 + LONG $0xff6f850f; WORD $0xffff // jne LBB32_89, $-145(%rip) -LBB36_96: - WORD $0x854d; BYTE $0xff // testq %r15, %r15 - WORD $0x8949; BYTE $0xfd // movq %rdi, %r13 - LONG $0x003c840f; WORD $0x0000 // je LBB36_99, $60(%rip) - WORD $0x014c; BYTE $0xca // addq %r9, %rdx - WORD $0x014c; BYTE $0xea // addq %r13, %rdx - LONG $0x62c28348 // addq $98, %rdx - LONG $0x07e7c149 // shlq $7, %r15 - WORD $0xf631 // xorl %esi, %esi - QUAD $0xfffff5eb056ffdc5 // vmovdqa $-2581(%rip), %ymm0 /* LCPI36_0(%rip) */ +LBB32_90: + WORD $0x854d; BYTE $0xdb // testq %r11, %r11 + LONG $0x0033840f; WORD $0x0000 // je LBB32_93, $51(%rip) + WORD $0x014c; BYTE $0xcb // addq %r9, %rbx + LONG $0x1f448d48; BYTE $0x62 // leaq $98(%rdi,%rbx), %rax + WORD $0xf749; BYTE $0xdb // negq %r11 + QUAD $0xfffff691056ffdc5 // vmovdqa $-2415(%rip), %ymm0 /* LCPI32_0(%rip) */ -LBB36_98: - LONG $0x447ffec5; WORD $0xa032 // vmovdqu %ymm0, $-96(%rdx,%rsi) - LONG $0x447ffec5; WORD $0xc032 // vmovdqu %ymm0, $-64(%rdx,%rsi) - LONG $0x447ffec5; WORD $0xe032 // vmovdqu %ymm0, $-32(%rdx,%rsi) - LONG $0x047ffec5; BYTE $0x32 // vmovdqu %ymm0, (%rdx,%rsi) - LONG $0x80ee8348 // subq $-128, %rsi - WORD $0x3949; BYTE $0xf7 // cmpq %rsi, %r15 - LONG $0xffdc850f; WORD $0xffff // jne LBB36_98, $-36(%rip) +LBB32_92: + LONG $0x407ffec5; BYTE $0xa0 // vmovdqu %ymm0, $-96(%rax) + LONG $0x407ffec5; BYTE $0xc0 // vmovdqu %ymm0, $-64(%rax) + LONG $0x407ffec5; BYTE $0xe0 // vmovdqu %ymm0, $-32(%rax) + LONG $0x007ffec5 // vmovdqu %ymm0, (%rax) + LONG $0x80e88348 // subq $-128, %rax + WORD $0xff49; BYTE $0xc3 // incq %r11 + LONG $0xffe0850f; WORD $0xffff // jne LBB32_92, $-32(%rip) -LBB36_99: - WORD $0x8949; BYTE $0xdf // movq %rbx, %r15 - WORD $0x0149; BYTE $0xcf // addq %rcx, %r15 - WORD $0x3949; BYTE $0xce // cmpq %rcx, %r14 - LONG $0x0017840f; WORD $0x0000 // je LBB36_102, $23(%rip) +LBB32_93: + WORD $0x014d; BYTE $0xf8 // addq %r15, %r8 + WORD $0x394c; BYTE $0xfe // cmpq %r15, %rsi + LONG $0x0025840f; WORD $0x0000 // je LBB32_96, $37(%rip) -LBB36_100: - WORD $0x0144; BYTE $0xd1 // addl %r10d, %ecx - WORD $0xd9f7 // negl %ecx - WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 +LBB32_94: + WORD $0x0145; BYTE $0xd7 // addl %r10d, %r15d + WORD $0xf741; BYTE $0xdf // negl %r15d + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 -LBB36_101: - LONG $0x3007c641 // movb $48, (%r15) - WORD $0xff49; BYTE $0xc7 // incq %r15 - WORD $0xc9ff // decl %ecx - LONG $0xfff1850f; WORD $0xffff // jne LBB36_101, $-15(%rip) +LBB32_95: + LONG $0x3000c641 // movb $48, (%r8) + WORD $0xff49; BYTE $0xc0 // incq %r8 + WORD $0xff41; BYTE $0xcf // decl %r15d + LONG $0xfff0850f; WORD $0xffff // jne LBB32_95, $-16(%rip) + +LBB32_96: + LONG $0x20048d4b // leaq (%r8,%r12), %rax + LONG $0x10fd8141; WORD $0x0027; BYTE $0x00 // cmpl $10000, %r13d + LONG $0x0063820f; WORD $0x0000 // jb LBB32_99, $99(%rip) + WORD $0x8944; BYTE $0xe9 // movl %r13d, %ecx + LONG $0x1759bb41; WORD $0xd1b7 // movl $3518437209, %r11d + LONG $0xd9af0f4c // imulq %rcx, %r11 + LONG $0x2debc149 // shrq $45, %r11 + LONG $0xf0cb6941; WORD $0xffd8; BYTE $0xff // imull $-10000, %r11d, %ecx + WORD $0x0144; BYTE $0xe9 // addl %r13d, %ecx + LONG $0x0190840f; WORD $0x0000 // je LBB32_101, $400(%rip) + WORD $0xca89 // movl %ecx, %edx + LONG $0x1fd26948; WORD $0xeb85; BYTE $0x51 // imulq $1374389535, %rdx, %rdx + LONG $0x25eac148 // shrq $37, %rdx + WORD $0xda6b; BYTE $0x64 // imull $100, %edx, %ebx + WORD $0xd929 // subl %ebx, %ecx + LONG $0x951d8d48; WORD $0x0037; BYTE $0x00 // leaq $14229(%rip), %rbx /* _Digits(%rip) */ + LONG $0x4b0cb70f // movzwl (%rbx,%rcx,2), %ecx + LONG $0xfe488966 // movw %cx, $-2(%rax) + LONG $0x530cb70f // movzwl (%rbx,%rdx,2), %ecx + LONG $0xfc488966 // movw %cx, $-4(%rax) + WORD $0x3145; BYTE $0xc9 // xorl %r9d, %r9d + LONG $0xfcc08348 // addq $-4, %rax + LONG $0x64fb8341 // cmpl $100, %r11d + LONG $0x0018830f; WORD $0x0000 // jae LBB32_103, $24(%rip) -LBB36_102: - LONG $0xd07d894c // movq %r15, $-48(%rbp) - WORD $0x014d; BYTE $0xc7 // addq %r8, %r15 - LONG $0x0027103d; BYTE $0x00 // cmpl $10000, %eax - LONG $0x005f820f; WORD $0x0000 // jb LBB36_105, $95(%rip) - WORD $0xc289 // movl %eax, %edx - LONG $0xb71759bb; BYTE $0xd1 // movl $3518437209, %ebx - LONG $0xdaaf0f48 // imulq %rdx, %rbx - LONG $0x2debc148 // shrq $45, %rbx - LONG $0xd8f0d369; WORD $0xffff // imull $-10000, %ebx, %edx - WORD $0xc201 // addl %eax, %edx - LONG $0x01c3840f; WORD $0x0000 // je LBB36_107, $451(%rip) - WORD $0xd089 // movl %edx, %eax - LONG $0x1fc06948; WORD $0xeb85; BYTE $0x51 // imulq $1374389535, %rax, %rax - LONG $0x25e8c148 // shrq $37, %rax - WORD $0xf06b; BYTE $0x64 // imull $100, %eax, %esi - WORD $0xf229 // subl %esi, %edx - LONG $0x59358d48; WORD $0x003b; BYTE $0x00 // leaq $15193(%rip), %rsi /* _Digits(%rip) */ - LONG $0x5614b70f // movzwl (%rsi,%rdx,2), %edx - LONG $0x57894166; BYTE $0xfe // movw %dx, $-2(%r15) - LONG $0x4604b70f // movzwl (%rsi,%rax,2), %eax - LONG $0x47894166; BYTE $0xfc // movw %ax, $-4(%r15) - WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d - LONG $0xfc578d49 // leaq $-4(%r15), %rdx - WORD $0xfb83; BYTE $0x64 // cmpl $100, %ebx - LONG $0x0018830f; WORD $0x0000 // jae LBB36_109, $24(%rip) +LBB32_100: + WORD $0x8944; BYTE $0xd9 // movl %r11d, %ecx + LONG $0x00004ee9; BYTE $0x00 // jmp LBB32_105, $78(%rip) -LBB36_106: - WORD $0xd889 // movl %ebx, %eax - LONG $0x00004ee9; BYTE $0x00 // jmp LBB36_111, $78(%rip) +LBB32_99: + WORD $0x3145; BYTE $0xc9 // xorl %r9d, %r9d + WORD $0x8945; BYTE $0xeb // movl %r13d, %r11d + LONG $0x64fb8341 // cmpl $100, %r11d + LONG $0xffe8820f; WORD $0xffff // jb LBB32_100, $-24(%rip) -LBB36_105: - WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d - WORD $0x894c; BYTE $0xfa // movq %r15, %rdx - WORD $0xc389 // movl %eax, %ebx - WORD $0xfb83; BYTE $0x64 // cmpl $100, %ebx - LONG $0xffe8820f; WORD $0xffff // jb LBB36_106, $-24(%rip) +LBB32_103: + WORD $0xff48; BYTE $0xc8 // decq %rax + LONG $0x52158d48; WORD $0x0037; BYTE $0x00 // leaq $14162(%rip), %rdx /* _Digits(%rip) */ + WORD $0x9090 // .p2align 4, 0x90 -LBB36_109: - WORD $0xff48; BYTE $0xca // decq %rdx - LONG $0x15358d48; WORD $0x003b; BYTE $0x00 // leaq $15125(%rip), %rsi /* _Digits(%rip) */ - LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 +LBB32_104: + WORD $0x8944; BYTE $0xd9 // movl %r11d, %ecx + LONG $0x1fc96948; WORD $0xeb85; BYTE $0x51 // imulq $1374389535, %rcx, %rcx + LONG $0x25e9c148 // shrq $37, %rcx + WORD $0xd96b; BYTE $0x64 // imull $100, %ecx, %ebx + WORD $0x8944; BYTE $0xde // movl %r11d, %esi + WORD $0xde29 // subl %ebx, %esi + LONG $0x7234b70f // movzwl (%rdx,%rsi,2), %esi + LONG $0xff708966 // movw %si, $-1(%rax) + LONG $0xfec08348 // addq $-2, %rax + LONG $0x0ffb8141; WORD $0x0027; BYTE $0x00 // cmpl $9999, %r11d + WORD $0x8941; BYTE $0xcb // movl %ecx, %r11d + LONG $0xffce870f; WORD $0xffff // ja LBB32_104, $-50(%rip) + +LBB32_105: + WORD $0xf983; BYTE $0x0a // cmpl $10, %ecx + LONG $0x0016820f; WORD $0x0000 // jb LBB32_107, $22(%rip) + WORD $0xc889 // movl %ecx, %eax + LONG $0x0c0d8d48; WORD $0x0037; BYTE $0x00 // leaq $14092(%rip), %rcx /* _Digits(%rip) */ + LONG $0x4104b70f // movzwl (%rcx,%rax,2), %eax + LONG $0x00894166 // movw %ax, (%r8) + LONG $0x000006e9; BYTE $0x00 // jmp LBB32_108, $6(%rip) -LBB36_110: - WORD $0xd889 // movl %ebx, %eax - LONG $0x1fc06948; WORD $0xeb85; BYTE $0x51 // imulq $1374389535, %rax, %rax - LONG $0x25e8c148 // shrq $37, %rax - WORD $0xf86b; BYTE $0x64 // imull $100, %eax, %edi - WORD $0xd989 // movl %ebx, %ecx - WORD $0xf929 // subl %edi, %ecx - LONG $0x4e0cb70f // movzwl (%rsi,%rcx,2), %ecx - LONG $0xff4a8966 // movw %cx, $-1(%rdx) - LONG $0xfec28348 // addq $-2, %rdx - LONG $0x270ffb81; WORD $0x0000 // cmpl $9999, %ebx - WORD $0xc389 // movl %eax, %ebx - LONG $0xffd2870f; WORD $0xffff // ja LBB36_110, $-46(%rip) +LBB32_107: + WORD $0xc180; BYTE $0x30 // addb $48, %cl + WORD $0x8841; BYTE $0x08 // movb %cl, (%r8) -LBB36_111: - WORD $0x894d; BYTE $0xe9 // movq %r13, %r9 - WORD $0xf883; BYTE $0x0a // cmpl $10, %eax - LONG $0x0019820f; WORD $0x0000 // jb LBB36_113, $25(%rip) - WORD $0xc089 // movl %eax, %eax - LONG $0xcd0d8d48; WORD $0x003a; BYTE $0x00 // leaq $15053(%rip), %rcx /* _Digits(%rip) */ - LONG $0x4104b70f // movzwl (%rcx,%rax,2), %eax - LONG $0xd04d8b48 // movq $-48(%rbp), %rcx - WORD $0x8966; BYTE $0x01 // movw %ax, (%rcx) - LONG $0x000008e9; BYTE $0x00 // jmp LBB36_114, $8(%rip) - -LBB36_113: - WORD $0x3004 // addb $48, %al - LONG $0xd04d8b48 // movq $-48(%rbp), %rcx - WORD $0x0188 // movb %al, (%rcx) - -LBB36_114: - WORD $0x294d; BYTE $0xf7 // subq %r14, %r15 - WORD $0x294d; BYTE $0xf0 // subq %r14, %r8 - WORD $0xff49; BYTE $0xc0 // incq %r8 - LONG $0x1e048d43 // leal (%r14,%r11), %eax - WORD $0xd8f6 // negb %al - LONG $0x33148d43 // leal (%r11,%r14), %edx - WORD $0xdaf7 // negl %edx - LONG $0x332c8d47 // leal (%r11,%r14), %r13d - WORD $0xff41; BYTE $0xcd // decl %r13d - LONG $0x33348d43 // leal (%r11,%r14), %esi - WORD $0xc683; BYTE $0xfe // addl $-2, %esi - WORD $0xc931 // xorl %ecx, %ecx +LBB32_108: + WORD $0x294d; BYTE $0xcc // subq %r9, %r12 + LONG $0x24548d49; BYTE $0x01 // leaq $1(%r12), %rdx + LONG $0x24748d49; BYTE $0x61 // leaq $97(%r12), %rsi + LONG $0x24448d49; BYTE $0x02 // leaq $2(%r12), %rax + LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 - // .p2align 4, 0x90 -LBB36_115: - WORD $0xc389 // movl %eax, %ebx - WORD $0x438d; BYTE $0x03 // leal $3(%rbx), %eax - WORD $0xc6ff // incl %esi - LONG $0x0f7c8041; WORD $0x30ff // cmpb $48, $-1(%r15,%rcx) - LONG $0xff498d48 // leaq $-1(%rcx), %rcx - LONG $0xffe9840f; WORD $0xffff // je LBB36_115, $-23(%rip) - LONG $0x0f048d49 // leaq (%r15,%rcx), %rax - WORD $0xff48; BYTE $0xc0 // incq %rax +LBB32_109: + WORD $0xff48; BYTE $0xce // decq %rsi + WORD $0xff48; BYTE $0xca // decq %rdx + WORD $0xff48; BYTE $0xc8 // decq %rax + LONG $0x207c8043; WORD $0x30ff // cmpb $48, $-1(%r8,%r12) + LONG $0x24648d4d; BYTE $0xff // leaq $-1(%r12), %r12 + LONG $0xffe6840f; WORD $0xffff // je LBB32_109, $-26(%rip) + LONG $0x100c8d4d // leaq (%r8,%rdx), %r9 WORD $0x8545; BYTE $0xd2 // testl %r10d, %r10d - LONG $0x00b28e0f; WORD $0x0000 // jle LBB36_121, $178(%rip) - WORD $0x2945; BYTE $0xf4 // subl %r14d, %r12d - LONG $0x0c3c8d41 // leal (%r12,%rcx), %edi - WORD $0xc7ff // incl %edi - WORD $0x3941; BYTE $0xfa // cmpl %edi, %r10d - LONG $0x002d8d0f; WORD $0x0000 // jge LBB36_122, $45(%rip) - WORD $0x6348; BYTE $0xc2 // movslq %edx, %rax - LONG $0x08348d48 // leaq (%rax,%rcx), %rsi - WORD $0xff48; BYTE $0xc6 // incq %rsi - WORD $0xf685 // testl %esi, %esi - WORD $0x894d; BYTE $0xcd // movq %r9, %r13 - LONG $0x011a8e0f; WORD $0x0000 // jle LBB36_133, $282(%rip) - WORD $0x8941; BYTE $0xf0 // movl %esi, %r8d - LONG $0xff508d49 // leaq $-1(%r8), %rdx - LONG $0x03fa8348 // cmpq $3, %rdx - LONG $0x009a830f; WORD $0x0000 // jae LBB36_127, $154(%rip) - WORD $0xd231 // xorl %edx, %edx - LONG $0x0000c6e9; BYTE $0x00 // jmp LBB36_130, $198(%rip) - -LBB36_122: - WORD $0x8945; BYTE $0xea // movl %r13d, %r10d - WORD $0x2949; BYTE $0xca // subq %rcx, %r10 - WORD $0x8545; BYTE $0xd2 // testl %r10d, %r10d - LONG $0x00648e0f; WORD $0x0000 // jle LBB36_121, $100(%rip) - LONG $0x331c8d43 // leal (%r11,%r14), %ebx - WORD $0xc383; BYTE $0xfe // addl $-2, %ebx - WORD $0x2948; BYTE $0xcb // subq %rcx, %rbx - WORD $0xd231 // xorl %edx, %edx - WORD $0xfb83; BYTE $0x7f // cmpl $127, %ebx - WORD $0x894d; BYTE $0xcd // movq %r9, %r13 - LONG $0x0223820f; WORD $0x0000 // jb LBB36_140, $547(%rip) - WORD $0x0145; BYTE $0xde // addl %r11d, %r14d - LONG $0xfec68341 // addl $-2, %r14d - WORD $0x2949; BYTE $0xce // subq %rcx, %r14 - WORD $0x8941; BYTE $0xdb // movl %ebx, %r11d + LONG $0x00938e0f; WORD $0x0000 // jle LBB32_115, $147(%rip) + WORD $0x8944; BYTE $0xc9 // movl %r9d, %ecx + WORD $0x2944; BYTE $0xc1 // subl %r8d, %ecx + WORD $0xcb89 // movl %ecx, %ebx + WORD $0x2944; BYTE $0xd3 // subl %r10d, %ebx + LONG $0x00278e0f; WORD $0x0000 // jle LBB32_116, $39(%rip) + WORD $0xdb85 // testl %ebx, %ebx + LONG $0x00fa8e0f; WORD $0x0000 // jle LBB32_127, $250(%rip) + WORD $0x8941; BYTE $0xdb // movl %ebx, %r11d + LONG $0xff4b8d49 // leaq $-1(%r11), %rcx + WORD $0x8945; BYTE $0xd9 // movl %r11d, %r9d + LONG $0x03e18341 // andl $3, %r9d + LONG $0x03f98348 // cmpq $3, %rcx + LONG $0x0083830f; WORD $0x0000 // jae LBB32_121, $131(%rip) + WORD $0xc931 // xorl %ecx, %ecx + LONG $0x0000ade9; BYTE $0x00 // jmp LBB32_124, $173(%rip) + +LBB32_116: + WORD $0x8945; BYTE $0xd6 // movl %r10d, %r14d + WORD $0x2941; BYTE $0xce // subl %ecx, %r14d + LONG $0x004f8e0f; WORD $0x0000 // jle LBB32_115, $79(%rip) + WORD $0x0145; BYTE $0xc2 // addl %r8d, %r10d + WORD $0x8945; BYTE $0xcb // movl %r9d, %r11d + WORD $0xf741; BYTE $0xd3 // notl %r11d + WORD $0x0145; BYTE $0xd3 // addl %r10d, %r11d + WORD $0xc031 // xorl %eax, %eax + LONG $0x7efb8341 // cmpl $126, %r11d + LONG $0x01bd860f; WORD $0x0000 // jbe LBB32_134, $445(%rip) WORD $0xff49; BYTE $0xc3 // incq %r11 - WORD $0x894c; BYTE $0xda // movq %r11, %rdx - LONG $0x80e28348 // andq $-128, %rdx - LONG $0xd07d8b48 // movq $-48(%rbp), %rdi - WORD $0x014c; BYTE $0xc7 // addq %r8, %rdi - WORD $0xf089 // movl %esi, %eax - WORD $0xff48; BYTE $0xc0 // incq %rax + WORD $0x894c; BYTE $0xd8 // movq %r11, %rax LONG $0x80e08348 // andq $-128, %rax - WORD $0x0148; BYTE $0xf8 // addq %rdi, %rax - LONG $0x80728d48 // leaq $-128(%rdx), %rsi - WORD $0x8949; BYTE $0xf0 // movq %rsi, %r8 - LONG $0x07e8c149 // shrq $7, %r8 - WORD $0xff49; BYTE $0xc0 // incq %r8 - LONG $0x80fe8148; WORD $0x0001; BYTE $0x00 // cmpq $384, %rsi - LONG $0x00ae830f; WORD $0x0000 // jae LBB36_134, $174(%rip) - WORD $0xf631 // xorl %esi, %esi - LONG $0x000163e9; BYTE $0x00 // jmp LBB36_136, $355(%rip) + LONG $0x000c8d4d // leaq (%r8,%rax), %r9 + LONG $0x80488d48 // leaq $-128(%rax), %rcx + WORD $0x8949; BYTE $0xcf // movq %rcx, %r15 + LONG $0x07efc149 // shrq $7, %r15 + WORD $0xff49; BYTE $0xc7 // incq %r15 + WORD $0x8945; BYTE $0xfa // movl %r15d, %r10d + LONG $0x03e28341 // andl $3, %r10d + LONG $0x80f98148; WORD $0x0001; BYTE $0x00 // cmpq $384, %rcx + LONG $0x0097830f; WORD $0x0000 // jae LBB32_128, $151(%rip) + WORD $0xc931 // xorl %ecx, %ecx + LONG $0x000139e9; BYTE $0x00 // jmp LBB32_130, $313(%rip) -LBB36_121: - WORD $0x894d; BYTE $0xcd // movq %r9, %r13 - LONG $0x0001e0e9; BYTE $0x00 // jmp LBB36_92, $480(%rip) +LBB32_115: + WORD $0x894d; BYTE $0xc8 // movq %r9, %r8 + LONG $0x0001a0e9; BYTE $0x00 // jmp LBB32_136, $416(%rip) -LBB36_107: - LONG $0x0004be41; WORD $0x0000 // movl $4, %r14d - LONG $0xfc578d49 // leaq $-4(%r15), %rdx - WORD $0xfb83; BYTE $0x64 // cmpl $100, %ebx - LONG $0xfe65820f; WORD $0xffff // jb LBB36_106, $-411(%rip) - LONG $0xfffe78e9; BYTE $0xff // jmp LBB36_109, $-392(%rip) +LBB32_101: + LONG $0x0004b941; WORD $0x0000 // movl $4, %r9d + LONG $0xfcc08348 // addq $-4, %rax + LONG $0x64fb8341 // cmpl $100, %r11d + LONG $0xfe96820f; WORD $0xffff // jb LBB32_100, $-362(%rip) + LONG $0xfffea9e9; BYTE $0xff // jmp LBB32_103, $-343(%rip) -LBB36_127: - WORD $0xe683; BYTE $0xfc // andl $-4, %esi - WORD $0xf748; BYTE $0xde // negq %rsi - WORD $0xd231 // xorl %edx, %edx - QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 +LBB32_121: + LONG $0xfce38341 // andl $-4, %r11d + WORD $0xf749; BYTE $0xdb // negq %r11 + WORD $0xc931 // xorl %ecx, %ecx + QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90 -LBB36_128: - LONG $0x173c8d49 // leaq (%r15,%rdx), %rdi - LONG $0xfd39448b // movl $-3(%rcx,%rdi), %eax - LONG $0xfe394489 // movl %eax, $-2(%rcx,%rdi) - LONG $0xfcc28348 // addq $-4, %rdx - WORD $0x3948; BYTE $0xd6 // cmpq %rdx, %rsi - LONG $0xffe7850f; WORD $0xffff // jne LBB36_128, $-25(%rip) - WORD $0xf748; BYTE $0xda // negq %rdx +LBB32_122: + LONG $0x081c8d49 // leaq (%r8,%rcx), %rbx + LONG $0xfc1a748b // movl $-4(%rdx,%rbx), %esi + LONG $0xfd1a7489 // movl %esi, $-3(%rdx,%rbx) + LONG $0xfcc18348 // addq $-4, %rcx + WORD $0x3949; BYTE $0xcb // cmpq %rcx, %r11 + LONG $0xffe7850f; WORD $0xffff // jne LBB32_122, $-25(%rip) + WORD $0xf748; BYTE $0xd9 // negq %rcx -LBB36_130: - LONG $0x03c0f641 // testb $3, %r8b - LONG $0x0032840f; WORD $0x0000 // je LBB36_133, $50(%rip) - WORD $0xb60f; BYTE $0xc3 // movzbl %bl, %eax - WORD $0xe083; BYTE $0x03 // andl $3, %eax - WORD $0xf748; BYTE $0xd8 // negq %rax - WORD $0x894c; BYTE $0xfe // movq %r15, %rsi - WORD $0x2948; BYTE $0xd6 // subq %rdx, %rsi - WORD $0xd231 // xorl %edx, %edx - QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90 +LBB32_124: + WORD $0x854d; BYTE $0xc9 // testq %r9, %r9 + LONG $0x0025840f; WORD $0x0000 // je LBB32_127, $37(%rip) + WORD $0xf749; BYTE $0xd9 // negq %r9 + WORD $0x894c; BYTE $0xc2 // movq %r8, %rdx + WORD $0x2948; BYTE $0xca // subq %rcx, %rdx + WORD $0xc931 // xorl %ecx, %ecx -LBB36_132: - LONG $0x163c8d48 // leaq (%rsi,%rdx), %rdi - LONG $0x391cb60f // movzbl (%rcx,%rdi), %ebx - LONG $0x01395c88 // movb %bl, $1(%rcx,%rdi) - WORD $0xff48; BYTE $0xca // decq %rdx - WORD $0x3948; BYTE $0xd0 // cmpq %rdx, %rax - LONG $0xffe8850f; WORD $0xffff // jne LBB36_132, $-24(%rip) + // .p2align 4, 0x90 +LBB32_126: + LONG $0x0a348d48 // leaq (%rdx,%rcx), %rsi + LONG $0x1cb60f41; BYTE $0x34 // movzbl (%r12,%rsi), %ebx + LONG $0x345c8841; BYTE $0x01 // movb %bl, $1(%r12,%rsi) + WORD $0xff48; BYTE $0xc9 // decq %rcx + WORD $0x3949; BYTE $0xc9 // cmpq %rcx, %r9 + LONG $0xffe6850f; WORD $0xffff // jne LBB32_126, $-26(%rip) + +LBB32_127: + WORD $0x6349; BYTE $0xca // movslq %r10d, %rcx + LONG $0x0804c641; BYTE $0x2e // movb $46, (%r8,%rcx) + WORD $0x0149; BYTE $0xc0 // addq %rax, %r8 + LONG $0x000118e9; BYTE $0x00 // jmp LBB32_136, $280(%rip) + +LBB32_128: + LONG $0xfce78349 // andq $-4, %r15 + WORD $0xf749; BYTE $0xdf // negq %r15 + WORD $0xc931 // xorl %ecx, %ecx + QUAD $0xfffff3e5056ffdc5 // vmovdqa $-3099(%rip), %ymm0 /* LCPI32_0(%rip) */ + +LBB32_129: + LONG $0x081c8d49 // leaq (%r8,%rcx), %rbx + LONG $0x047ffec5; BYTE $0x1a // vmovdqu %ymm0, (%rdx,%rbx) + LONG $0x447ffec5; WORD $0x201a // vmovdqu %ymm0, $32(%rdx,%rbx) + LONG $0x447ffec5; WORD $0x401a // vmovdqu %ymm0, $64(%rdx,%rbx) + LONG $0x447ffec5; WORD $0x601a // vmovdqu %ymm0, $96(%rdx,%rbx) + QUAD $0x0000801a847ffec5; BYTE $0x00 // vmovdqu %ymm0, $128(%rdx,%rbx) + QUAD $0x0000a01a847ffec5; BYTE $0x00 // vmovdqu %ymm0, $160(%rdx,%rbx) + QUAD $0x0000c01a847ffec5; BYTE $0x00 // vmovdqu %ymm0, $192(%rdx,%rbx) + QUAD $0x0000e01a847ffec5; BYTE $0x00 // vmovdqu %ymm0, $224(%rdx,%rbx) + QUAD $0x0001001a847ffec5; BYTE $0x00 // vmovdqu %ymm0, $256(%rdx,%rbx) + QUAD $0x0001201a847ffec5; BYTE $0x00 // vmovdqu %ymm0, $288(%rdx,%rbx) + QUAD $0x0001401a847ffec5; BYTE $0x00 // vmovdqu %ymm0, $320(%rdx,%rbx) + QUAD $0x0001601a847ffec5; BYTE $0x00 // vmovdqu %ymm0, $352(%rdx,%rbx) + QUAD $0x0001801a847ffec5; BYTE $0x00 // vmovdqu %ymm0, $384(%rdx,%rbx) + QUAD $0x0001a01a847ffec5; BYTE $0x00 // vmovdqu %ymm0, $416(%rdx,%rbx) + QUAD $0x0001c01a847ffec5; BYTE $0x00 // vmovdqu %ymm0, $448(%rdx,%rbx) + QUAD $0x0001e01a847ffec5; BYTE $0x00 // vmovdqu %ymm0, $480(%rdx,%rbx) + LONG $0x00c18148; WORD $0x0002; BYTE $0x00 // addq $512, %rcx + LONG $0x04c78349 // addq $4, %r15 + LONG $0xff68850f; WORD $0xffff // jne LBB32_129, $-152(%rip) -LBB36_133: - WORD $0x8944; BYTE $0xd0 // movl %r10d, %eax - LONG $0xd0558b48 // movq $-48(%rbp), %rdx - LONG $0x2e0204c6 // movb $46, (%rdx,%rax) - LONG $0x0f048d49 // leaq (%r15,%rcx), %rax - LONG $0x02c08348 // addq $2, %rax - LONG $0x000141e9; BYTE $0x00 // jmp LBB36_92, $321(%rip) +LBB32_130: + WORD $0x0149; BYTE $0xd1 // addq %rdx, %r9 + WORD $0x854d; BYTE $0xd2 // testq %r10, %r10 + LONG $0x0035840f; WORD $0x0000 // je LBB32_133, $53(%rip) + WORD $0x0149; BYTE $0xc8 // addq %rcx, %r8 + WORD $0x0149; BYTE $0xf0 // addq %rsi, %r8 + WORD $0xf749; BYTE $0xda // negq %r10 + QUAD $0xfffff330056ffdc5 // vmovdqa $-3280(%rip), %ymm0 /* LCPI32_0(%rip) */ + +LBB32_132: + LONG $0x7f7ec1c4; WORD $0xa040 // vmovdqu %ymm0, $-96(%r8) + LONG $0x7f7ec1c4; WORD $0xc040 // vmovdqu %ymm0, $-64(%r8) + LONG $0x7f7ec1c4; WORD $0xe040 // vmovdqu %ymm0, $-32(%r8) + LONG $0x7f7ec1c4; BYTE $0x00 // vmovdqu %ymm0, (%r8) + LONG $0x80e88349 // subq $-128, %r8 + WORD $0xff49; BYTE $0xc2 // incq %r10 + LONG $0xffdc850f; WORD $0xffff // jne LBB32_132, $-36(%rip) -LBB36_134: - WORD $0x8944; BYTE $0xf3 // movl %r14d, %ebx - WORD $0xff48; BYTE $0xc3 // incq %rbx - LONG $0x80e38348 // andq $-128, %rbx - LONG $0x80c38348 // addq $-128, %rbx - LONG $0x07ebc148 // shrq $7, %rbx - WORD $0xff48; BYTE $0xc3 // incq %rbx - LONG $0xfce38348 // andq $-4, %rbx - WORD $0xf631 // xorl %esi, %esi - QUAD $0xfffff2ed056ffdc5 // vmovdqa $-3347(%rip), %ymm0 /* LCPI36_0(%rip) */ - -LBB36_135: - LONG $0x373c8d49 // leaq (%r15,%rsi), %rdi - LONG $0x447ffec5; WORD $0x0139 // vmovdqu %ymm0, $1(%rcx,%rdi) - LONG $0x447ffec5; WORD $0x2139 // vmovdqu %ymm0, $33(%rcx,%rdi) - LONG $0x447ffec5; WORD $0x4139 // vmovdqu %ymm0, $65(%rcx,%rdi) - LONG $0x447ffec5; WORD $0x6139 // vmovdqu %ymm0, $97(%rcx,%rdi) - QUAD $0x00008139847ffec5; BYTE $0x00 // vmovdqu %ymm0, $129(%rcx,%rdi) - QUAD $0x0000a139847ffec5; BYTE $0x00 // vmovdqu %ymm0, $161(%rcx,%rdi) - QUAD $0x0000c139847ffec5; BYTE $0x00 // vmovdqu %ymm0, $193(%rcx,%rdi) - QUAD $0x0000e139847ffec5; BYTE $0x00 // vmovdqu %ymm0, $225(%rcx,%rdi) - QUAD $0x00010139847ffec5; BYTE $0x00 // vmovdqu %ymm0, $257(%rcx,%rdi) - QUAD $0x00012139847ffec5; BYTE $0x00 // vmovdqu %ymm0, $289(%rcx,%rdi) - QUAD $0x00014139847ffec5; BYTE $0x00 // vmovdqu %ymm0, $321(%rcx,%rdi) - QUAD $0x00016139847ffec5; BYTE $0x00 // vmovdqu %ymm0, $353(%rcx,%rdi) - QUAD $0x00018139847ffec5; BYTE $0x00 // vmovdqu %ymm0, $385(%rcx,%rdi) - QUAD $0x0001a139847ffec5; BYTE $0x00 // vmovdqu %ymm0, $417(%rcx,%rdi) - QUAD $0x0001c139847ffec5; BYTE $0x00 // vmovdqu %ymm0, $449(%rcx,%rdi) - QUAD $0x0001e139847ffec5; BYTE $0x00 // vmovdqu %ymm0, $481(%rcx,%rdi) - LONG $0x00c68148; WORD $0x0002; BYTE $0x00 // addq $512, %rsi - LONG $0xfcc38348 // addq $-4, %rbx - LONG $0xff67850f; WORD $0xffff // jne LBB36_135, $-153(%rip) - -LBB36_136: - WORD $0x0148; BYTE $0xc8 // addq %rcx, %rax - LONG $0x03c0f641 // testb $3, %r8b - LONG $0x005a840f; WORD $0x0000 // je LBB36_139, $90(%rip) - WORD $0xff41; BYTE $0xc6 // incl %r14d - LONG $0x80e68141; WORD $0x0001; BYTE $0x00 // andl $384, %r14d - LONG $0x80c68341 // addl $-128, %r14d - LONG $0x07eec141 // shrl $7, %r14d - WORD $0xfe41; BYTE $0xc6 // incb %r14b - LONG $0xc6b60f45 // movzbl %r14b, %r8d - LONG $0x03e08341 // andl $3, %r8d - LONG $0x07e0c149 // shlq $7, %r8 - WORD $0x014c; BYTE $0xfe // addq %r15, %rsi - LONG $0x61c68348 // addq $97, %rsi - WORD $0xdb31 // xorl %ebx, %ebx - QUAD $0xfffff215056ffdc5 // vmovdqa $-3563(%rip), %ymm0 /* LCPI36_0(%rip) */ - -LBB36_138: - LONG $0x1e3c8d48 // leaq (%rsi,%rbx), %rdi - LONG $0x447ffec5; WORD $0xa039 // vmovdqu %ymm0, $-96(%rcx,%rdi) - LONG $0x447ffec5; WORD $0xc039 // vmovdqu %ymm0, $-64(%rcx,%rdi) - LONG $0x447ffec5; WORD $0xe039 // vmovdqu %ymm0, $-32(%rcx,%rdi) - LONG $0x047ffec5; BYTE $0x39 // vmovdqu %ymm0, (%rcx,%rdi) - LONG $0x80eb8348 // subq $-128, %rbx - WORD $0x3949; BYTE $0xd8 // cmpq %rbx, %r8 - LONG $0xffd8850f; WORD $0xffff // jne LBB36_138, $-40(%rip) +LBB32_133: + WORD $0x894d; BYTE $0xc8 // movq %r9, %r8 + WORD $0x3949; BYTE $0xc3 // cmpq %rax, %r11 + LONG $0x0022840f; WORD $0x0000 // je LBB32_136, $34(%rip) -LBB36_139: - WORD $0x3949; BYTE $0xd3 // cmpq %rdx, %r11 - LONG $0x0015840f; WORD $0x0000 // je LBB36_92, $21(%rip) - LONG $0x90909090 // .p2align 4, 0x90 +LBB32_134: + WORD $0x894d; BYTE $0xc8 // movq %r9, %r8 + QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 -LBB36_140: - WORD $0x00c6; BYTE $0x30 // movb $48, (%rax) - WORD $0xff48; BYTE $0xc0 // incq %rax - WORD $0xc2ff // incl %edx - WORD $0x3944; BYTE $0xd2 // cmpl %r10d, %edx - LONG $0xffef8c0f; WORD $0xffff // jl LBB36_140, $-17(%rip) +LBB32_135: + LONG $0x3000c641 // movb $48, (%r8) + WORD $0xff49; BYTE $0xc0 // incq %r8 + WORD $0xc0ff // incl %eax + WORD $0x3944; BYTE $0xf0 // cmpl %r14d, %eax + LONG $0xffee8c0f; WORD $0xffff // jl LBB32_135, $-18(%rip) -LBB36_92: - WORD $0x2944; BYTE $0xe8 // subl %r13d, %eax +LBB32_136: + WORD $0x2941; BYTE $0xf8 // subl %edi, %r8d -LBB36_93: - LONG $0x08c48348 // addq $8, %rsp +LBB32_137: + WORD $0x8944; BYTE $0xc0 // movl %r8d, %eax BYTE $0x5b // popq %rbx WORD $0x5c41 // popq %r12 WORD $0x5d41 // popq %r13 @@ -11046,45 +10663,44 @@ LBB36_93: WORD $0xf8c5; BYTE $0x77 // vzeroupper BYTE $0xc3 // retq -LBB36_141: - WORD $0xc031 // xorl %eax, %eax - LONG $0xffffe7e9; BYTE $0xff // jmp LBB36_93, $-25(%rip) +LBB32_138: + WORD $0x3145; BYTE $0xc0 // xorl %r8d, %r8d + LONG $0xffffe7e9; BYTE $0xff // jmp LBB32_137, $-25(%rip) -LBB36_142: - LONG $0xd07d8948 // movq %rdi, $-48(%rbp) - LONG $0xff6bb841; WORD $0xffff // movl $-149, %r8d - WORD $0x8941; BYTE $0xc7 // movl %eax, %r15d - LONG $0xfff257e9; BYTE $0xff // jmp LBB36_8, $-3497(%rip) - BYTE $0x90 // .p2align 4, 0x90 +LBB32_139: + LONG $0xff6bbf41; WORD $0xffff // movl $-149, %r15d + WORD $0xc689 // movl %eax, %esi + LONG $0xfff352e9; BYTE $0xff // jmp LBB32_5, $-3246(%rip) + LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 _format_significand: BYTE $0x55 // pushq %rbp WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp WORD $0x5641 // pushq %r14 BYTE $0x53 // pushq %rbx - WORD $0x8941; BYTE $0xd0 // movl %edx, %r8d + WORD $0x634c; BYTE $0xc2 // movslq %edx, %r8 WORD $0x0149; BYTE $0xf0 // addq %rsi, %r8 WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax LONG $0x20e8c148 // shrq $32, %rax - LONG $0x001c850f; WORD $0x0000 // jne LBB37_2, $28(%rip) + LONG $0x001c850f; WORD $0x0000 // jne LBB33_2, $28(%rip) WORD $0x3145; BYTE $0xc9 // xorl %r9d, %r9d WORD $0x894d; BYTE $0xc6 // movq %r8, %r14 WORD $0x8948; BYTE $0xfa // movq %rdi, %rdx LONG $0x2710fa81; WORD $0x0000 // cmpl $10000, %edx - LONG $0x00e3830f; WORD $0x0000 // jae LBB37_8, $227(%rip) + LONG $0x00e3830f; WORD $0x0000 // jae LBB33_8, $227(%rip) -LBB37_7: +LBB33_7: WORD $0xd789 // movl %edx, %edi - LONG $0x000132e9; BYTE $0x00 // jmp LBB37_10, $306(%rip) + LONG $0x000132e9; BYTE $0x00 // jmp LBB33_10, $306(%rip) -LBB37_2: +LBB33_2: QUAD $0x77118461cefdb948; WORD $0xabcc // movabsq $-6067343680855748867, %rcx WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax WORD $0xf748; BYTE $0xe1 // mulq %rcx LONG $0x1aeac148 // shrq $26, %rdx LONG $0x1f00ca69; WORD $0xfa0a // imull $-100000000, %edx, %ecx WORD $0xf901 // addl %edi, %ecx - LONG $0x00a4840f; WORD $0x0000 // je LBB37_3, $164(%rip) + LONG $0x00a4840f; WORD $0x0000 // je LBB33_3, $164(%rip) WORD $0xc889 // movl %ecx, %eax LONG $0x1759b941; WORD $0xd1b7 // movl $3518437209, %r9d LONG $0xc1af0f49 // imulq %r9, %rax @@ -11110,7 +10726,7 @@ LBB37_2: WORD $0xcf6b; BYTE $0x64 // imull $100, %edi, %ecx WORD $0xc829 // subl %ecx, %eax LONG $0xd8b70f44 // movzwl %ax, %r11d - LONG $0xe30d8d48; WORD $0x0036; BYTE $0x00 // leaq $14051(%rip), %rcx /* _Digits(%rip) */ + LONG $0x930d8d48; WORD $0x0033; BYTE $0x00 // leaq $13203(%rip), %rcx /* _Digits(%rip) */ LONG $0x04b70f42; BYTE $0x51 // movzwl (%rcx,%r10,2), %eax LONG $0x40894166; BYTE $0xfe // movw %ax, $-2(%r8) LONG $0x04b70f42; BYTE $0x49 // movzwl (%rcx,%r9,2), %eax @@ -11122,21 +10738,21 @@ LBB37_2: WORD $0x3145; BYTE $0xc9 // xorl %r9d, %r9d LONG $0xf8708d4d // leaq $-8(%r8), %r14 LONG $0x2710fa81; WORD $0x0000 // cmpl $10000, %edx - LONG $0xff38820f; WORD $0xffff // jb LBB37_7, $-200(%rip) - LONG $0x000016e9; BYTE $0x00 // jmp LBB37_8, $22(%rip) + LONG $0xff38820f; WORD $0xffff // jb LBB33_7, $-200(%rip) + LONG $0x000016e9; BYTE $0x00 // jmp LBB33_8, $22(%rip) -LBB37_3: +LBB33_3: LONG $0x0008b941; WORD $0x0000 // movl $8, %r9d LONG $0xf8708d4d // leaq $-8(%r8), %r14 LONG $0x2710fa81; WORD $0x0000 // cmpl $10000, %edx - LONG $0xff1d820f; WORD $0xffff // jb LBB37_7, $-227(%rip) + LONG $0xff1d820f; WORD $0xffff // jb LBB33_7, $-227(%rip) -LBB37_8: +LBB33_8: LONG $0x1759ba41; WORD $0xd1b7 // movl $3518437209, %r10d - LONG $0x811d8d4c; WORD $0x0036; BYTE $0x00 // leaq $13953(%rip), %r11 /* _Digits(%rip) */ + LONG $0x311d8d4c; WORD $0x0033; BYTE $0x00 // leaq $13105(%rip), %r11 /* _Digits(%rip) */ BYTE $0x90 // .p2align 4, 0x90 -LBB37_9: +LBB33_9: WORD $0xd789 // movl %edx, %edi LONG $0xfaaf0f49 // imulq %r10, %rdi LONG $0x2defc148 // shrq $45, %rdi @@ -11153,22 +10769,22 @@ LBB37_9: LONG $0xfcc68349 // addq $-4, %r14 LONG $0xe0fffa81; WORD $0x05f5 // cmpl $99999999, %edx WORD $0xfa89 // movl %edi, %edx - LONG $0xffb8870f; WORD $0xffff // ja LBB37_9, $-72(%rip) + LONG $0xffb8870f; WORD $0xffff // ja LBB33_9, $-72(%rip) -LBB37_10: +LBB33_10: WORD $0xff83; BYTE $0x64 // cmpl $100, %edi - LONG $0x0020830f; WORD $0x0000 // jae LBB37_11, $32(%rip) + LONG $0x0020830f; WORD $0x0000 // jae LBB33_11, $32(%rip) WORD $0xff83; BYTE $0x0a // cmpl $10, %edi - LONG $0x004d820f; WORD $0x0000 // jb LBB37_14, $77(%rip) + LONG $0x004d820f; WORD $0x0000 // jb LBB33_14, $77(%rip) -LBB37_13: +LBB33_13: WORD $0xf889 // movl %edi, %eax - LONG $0x1d0d8d48; WORD $0x0036; BYTE $0x00 // leaq $13853(%rip), %rcx /* _Digits(%rip) */ + LONG $0xcd0d8d48; WORD $0x0032; BYTE $0x00 // leaq $13005(%rip), %rcx /* _Digits(%rip) */ LONG $0x4104b70f // movzwl (%rcx,%rax,2), %eax LONG $0x46894166; BYTE $0xfe // movw %ax, $-2(%r14) - LONG $0x00003de9; BYTE $0x00 // jmp LBB37_15, $61(%rip) + LONG $0x00003de9; BYTE $0x00 // jmp LBB33_15, $61(%rip) -LBB37_11: +LBB33_11: WORD $0xb70f; BYTE $0xc7 // movzwl %di, %eax WORD $0xe8c1; BYTE $0x02 // shrl $2, %eax LONG $0x147bc069; WORD $0x0000 // imull $5243, %eax, %eax @@ -11176,19 +10792,19 @@ LBB37_11: WORD $0xc86b; BYTE $0x64 // imull $100, %eax, %ecx WORD $0xcf29 // subl %ecx, %edi WORD $0xb70f; BYTE $0xcf // movzwl %di, %ecx - LONG $0xf1158d48; WORD $0x0035; BYTE $0x00 // leaq $13809(%rip), %rdx /* _Digits(%rip) */ + LONG $0xa1158d48; WORD $0x0032; BYTE $0x00 // leaq $12961(%rip), %rdx /* _Digits(%rip) */ LONG $0x4a0cb70f // movzwl (%rdx,%rcx,2), %ecx LONG $0x4e894166; BYTE $0xfe // movw %cx, $-2(%r14) LONG $0xfec68349 // addq $-2, %r14 WORD $0xc789 // movl %eax, %edi WORD $0xff83; BYTE $0x0a // cmpl $10, %edi - LONG $0xffb3830f; WORD $0xffff // jae LBB37_13, $-77(%rip) + LONG $0xffb3830f; WORD $0xffff // jae LBB33_13, $-77(%rip) -LBB37_14: +LBB33_14: LONG $0x30c78040 // addb $48, %dil WORD $0x8840; BYTE $0x3e // movb %dil, (%rsi) -LBB37_15: +LBB33_15: WORD $0x294d; BYTE $0xc8 // subq %r9, %r8 WORD $0x894c; BYTE $0xc0 // movq %r8, %rax BYTE $0x5b // popq %rbx @@ -11200,170 +10816,166 @@ LBB37_15: _left_shift: BYTE $0x55 // pushq %rbp WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp - WORD $0x5741 // pushq %r15 WORD $0x5641 // pushq %r14 BYTE $0x53 // pushq %rbx WORD $0xf189 // movl %esi, %ecx - LONG $0x68c16b48 // imulq $104, %rcx, %rax - LONG $0x9a158d48; WORD $0x008f; BYTE $0x00 // leaq $36762(%rip), %rdx /* _LSHIFT_TAB(%rip) */ - LONG $0x10048b44 // movl (%rax,%rdx), %r8d - WORD $0x8b4c; BYTE $0x0f // movq (%rdi), %r9 - WORD $0x0148; BYTE $0xc2 // addq %rax, %rdx - LONG $0x04c28348 // addq $4, %rdx - LONG $0x10476348 // movslq $16(%rdi), %rax + LONG $0x68d16b48 // imulq $104, %rcx, %rdx + LONG $0x4c358d48; WORD $0x008c; BYTE $0x00 // leaq $35916(%rip), %rsi /* _LSHIFT_TAB(%rip) */ + LONG $0x32048b44 // movl (%rdx,%rsi), %r8d + WORD $0x8b4c; BYTE $0x17 // movq (%rdi), %r10 + LONG $0x104f634c // movslq $16(%rdi), %r9 + LONG $0x0432448a // movb $4(%rdx,%rsi), %al + WORD $0x854d; BYTE $0xc9 // testq %r9, %r9 + LONG $0x0036840f; WORD $0x0000 // je LBB34_6, $54(%rip) + LONG $0x32548d48; BYTE $0x05 // leaq $5(%rdx,%rsi), %rdx WORD $0xf631 // xorl %esi, %esi - WORD $0x8548; BYTE $0xc0 // testq %rax, %rax - LONG $0x0031840f; WORD $0x0000 // je LBB38_6, $49(%rip) QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 -LBB38_1: - LONG $0x321cb60f // movzbl (%rdx,%rsi), %ebx - WORD $0xdb84 // testb %bl, %bl - LONG $0x0025840f; WORD $0x0000 // je LBB38_8, $37(%rip) - LONG $0x311c3841 // cmpb %bl, (%r9,%rsi) - LONG $0x0189850f; WORD $0x0000 // jne LBB38_3, $393(%rip) +LBB34_3: + WORD $0xc084 // testb %al, %al + LONG $0x0025840f; WORD $0x0000 // je LBB34_8, $37(%rip) + LONG $0x32043841 // cmpb %al, (%r10,%rsi) + LONG $0x0189850f; WORD $0x0000 // jne LBB34_5, $393(%rip) + LONG $0x3204b60f // movzbl (%rdx,%rsi), %eax WORD $0xff48; BYTE $0xc6 // incq %rsi - WORD $0x3948; BYTE $0xf0 // cmpq %rsi, %rax - LONG $0xffde850f; WORD $0xffff // jne LBB38_1, $-34(%rip) - WORD $0xc689 // movl %eax, %esi + WORD $0x3949; BYTE $0xf1 // cmpq %rsi, %r9 + LONG $0xffde850f; WORD $0xffff // jne LBB34_3, $-34(%rip) -LBB38_6: - LONG $0x00323c80 // cmpb $0, (%rdx,%rsi) - LONG $0x0003840f; WORD $0x0000 // je LBB38_8, $3(%rip) +LBB34_6: + WORD $0xc084 // testb %al, %al + LONG $0x0003840f; WORD $0x0000 // je LBB34_8, $3(%rip) -LBB38_7: +LBB34_7: WORD $0xff41; BYTE $0xc8 // decl %r8d -LBB38_8: - WORD $0xc085 // testl %eax, %eax - LONG $0x00968e0f; WORD $0x0000 // jle LBB38_22, $150(%rip) - LONG $0x001c8d45 // leal (%r8,%rax), %r11d - WORD $0xc389 // movl %eax, %ebx - WORD $0x634d; BYTE $0xf3 // movslq %r11d, %r14 - WORD $0xff49; BYTE $0xce // decq %r14 - WORD $0xff48; BYTE $0xc3 // incq %rbx - WORD $0xd231 // xorl %edx, %edx - QUAD $0xcccccccccccdba49; WORD $0xcccc // movabsq $-3689348814741910323, %r10 - LONG $0x000023e9; BYTE $0x00 // jmp LBB38_10, $35(%rip) - LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 - -LBB38_11: - WORD $0x3004 // addb $48, %al - LONG $0x31048843 // movb %al, (%r9,%r14) - WORD $0x8b4c; BYTE $0x0f // movq (%rdi), %r9 +LBB34_8: + WORD $0x8545; BYTE $0xc9 // testl %r9d, %r9d + LONG $0x008c8e0f; WORD $0x0000 // jle LBB34_23, $140(%rip) + LONG $0x08048d43 // leal (%r8,%r9), %eax + WORD $0x634c; BYTE $0xf0 // movslq %eax, %r14 + WORD $0xff49; BYTE $0xce // decq %r14 + WORD $0xd231 // xorl %edx, %edx + QUAD $0xcccccccccccdbb49; WORD $0xcccc // movabsq $-3689348814741910323, %r11 + LONG $0x90909090 // .p2align 4, 0x90 -LBB38_18: - WORD $0xff41; BYTE $0xcb // decl %r11d - WORD $0xff49; BYTE $0xce // decq %r14 - WORD $0xff48; BYTE $0xcb // decq %rbx - LONG $0x01fb8348 // cmpq $1, %rbx - LONG $0x0049860f; WORD $0x0000 // jbe LBB38_12, $73(%rip) +LBB34_10: + LONG $0x74be0f4b; WORD $0xff0a // movsbq $-1(%r10,%r9), %rsi + LONG $0xd0c68348 // addq $-48, %rsi + WORD $0xd348; BYTE $0xe6 // shlq %cl, %rsi + WORD $0x0148; BYTE $0xd6 // addq %rdx, %rsi + WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax + WORD $0xf749; BYTE $0xe3 // mulq %r11 + LONG $0x03eac148 // shrq $3, %rdx + LONG $0x12048d48 // leaq (%rdx,%rdx), %rax + LONG $0x801c8d48 // leaq (%rax,%rax,4), %rbx + WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax + WORD $0x2948; BYTE $0xd8 // subq %rbx, %rax + LONG $0x0877394c // cmpq %r14, $8(%rdi) + LONG $0x000e860f; WORD $0x0000 // jbe LBB34_16, $14(%rip) + WORD $0x3004 // addb $48, %al + LONG $0x32048843 // movb %al, (%r10,%r14) + LONG $0x000013e9; BYTE $0x00 // jmp LBB34_18, $19(%rip) + WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 -LBB38_10: - WORD $0x438d; BYTE $0xfe // leal $-2(%rbx), %eax - LONG $0x34be0f49; BYTE $0x01 // movsbq (%r9,%rax), %rsi - LONG $0xd0c68348 // addq $-48, %rsi - WORD $0xd348; BYTE $0xe6 // shlq %cl, %rsi - WORD $0x0148; BYTE $0xd6 // addq %rdx, %rsi - WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax - WORD $0xf749; BYTE $0xe2 // mulq %r10 - LONG $0x03eac148 // shrq $3, %rdx - LONG $0x12048d48 // leaq (%rdx,%rdx), %rax - LONG $0x803c8d4c // leaq (%rax,%rax,4), %r15 - WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax - WORD $0x294c; BYTE $0xf8 // subq %r15, %rax - LONG $0x0877394c // cmpq %r14, $8(%rdi) - LONG $0xffb0870f; WORD $0xffff // ja LBB38_11, $-80(%rip) +LBB34_16: WORD $0x8548; BYTE $0xc0 // testq %rax, %rax - LONG $0xffb0840f; WORD $0xffff // je LBB38_18, $-80(%rip) + LONG $0x0007840f; WORD $0x0000 // je LBB34_18, $7(%rip) LONG $0x011c47c7; WORD $0x0000; BYTE $0x00 // movl $1, $28(%rdi) - LONG $0xffffa4e9; BYTE $0xff // jmp LBB38_18, $-92(%rip) -LBB38_12: +LBB34_18: + LONG $0x02f98349 // cmpq $2, %r9 + LONG $0x000e8c0f; WORD $0x0000 // jl LBB34_12, $14(%rip) + WORD $0xff49; BYTE $0xc9 // decq %r9 + WORD $0x8b4c; BYTE $0x17 // movq (%rdi), %r10 + WORD $0xff49; BYTE $0xce // decq %r14 + LONG $0xffff98e9; BYTE $0xff // jmp LBB34_10, $-104(%rip) + +LBB34_12: LONG $0x0afe8348 // cmpq $10, %rsi - LONG $0x0070830f; WORD $0x0000 // jae LBB38_13, $112(%rip) + LONG $0x0067830f; WORD $0x0000 // jae LBB34_13, $103(%rip) -LBB38_22: - LONG $0x10476348 // movslq $16(%rdi), %rax - WORD $0x6349; BYTE $0xc8 // movslq %r8d, %rcx - WORD $0x0148; BYTE $0xc1 // addq %rax, %rcx - WORD $0x4f89; BYTE $0x10 // movl %ecx, $16(%rdi) - LONG $0x08478b48 // movq $8(%rdi), %rax - WORD $0x3948; BYTE $0xc8 // cmpq %rcx, %rax - LONG $0x0005870f; WORD $0x0000 // ja LBB38_24, $5(%rip) +LBB34_23: + LONG $0x104f6348 // movslq $16(%rdi), %rcx + WORD $0x6349; BYTE $0xc0 // movslq %r8d, %rax + WORD $0x0148; BYTE $0xc8 // addq %rcx, %rax WORD $0x4789; BYTE $0x10 // movl %eax, $16(%rdi) - WORD $0xc189 // movl %eax, %ecx - -LBB38_24: - LONG $0x14470144 // addl %r8d, $20(%rdi) - WORD $0xc985 // testl %ecx, %ecx - LONG $0x00318e0f; WORD $0x0000 // jle LBB38_28, $49(%rip) - WORD $0x8b48; BYTE $0x07 // movq (%rdi), %rax - WORD $0xc989 // movl %ecx, %ecx - BYTE $0x90 // .p2align 4, 0x90 - -LBB38_26: - LONG $0xff518d48 // leaq $-1(%rcx), %rdx - WORD $0xd689 // movl %edx, %esi - LONG $0x30303c80 // cmpb $48, (%rax,%rsi) - LONG $0x0028850f; WORD $0x0000 // jne LBB38_30, $40(%rip) - WORD $0xc9ff // decl %ecx + LONG $0x084f8b48 // movq $8(%rdi), %rcx + WORD $0x3948; BYTE $0xc1 // cmpq %rax, %rcx + LONG $0x0005870f; WORD $0x0000 // ja LBB34_25, $5(%rip) WORD $0x4f89; BYTE $0x10 // movl %ecx, $16(%rdi) - LONG $0x01728d48 // leaq $1(%rdx), %rsi - WORD $0x8948; BYTE $0xd1 // movq %rdx, %rcx - LONG $0x01fe8348 // cmpq $1, %rsi - LONG $0xffda870f; WORD $0xffff // ja LBB38_26, $-38(%rip) - LONG $0x000006e9; BYTE $0x00 // jmp LBB38_29, $6(%rip) + WORD $0xc889 // movl %ecx, %eax -LBB38_28: - LONG $0x0007850f; WORD $0x0000 // jne LBB38_30, $7(%rip) +LBB34_25: + LONG $0x14470144 // addl %r8d, $20(%rdi) + WORD $0xc085 // testl %eax, %eax + LONG $0x002f8e0f; WORD $0x0000 // jle LBB34_29, $47(%rip) + WORD $0x8b48; BYTE $0x0f // movq (%rdi), %rcx + WORD $0xc289 // movl %eax, %edx + WORD $0xff48; BYTE $0xc2 // incq %rdx + QUAD $0x9090909090909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 -LBB38_29: - LONG $0x001447c7; WORD $0x0000; BYTE $0x00 // movl $0, $20(%rdi) +LBB34_27: + WORD $0xc8ff // decl %eax + LONG $0x30013c80 // cmpb $48, (%rcx,%rax) + LONG $0x0018850f; WORD $0x0000 // jne LBB34_31, $24(%rip) + WORD $0x4789; BYTE $0x10 // movl %eax, $16(%rdi) + WORD $0xff48; BYTE $0xca // decq %rdx + LONG $0x01fa8348 // cmpq $1, %rdx + LONG $0xffe48f0f; WORD $0xffff // jg LBB34_27, $-28(%rip) + +LBB34_29: + WORD $0xc085 // testl %eax, %eax + LONG $0x006b840f; WORD $0x0000 // je LBB34_30, $107(%rip) -LBB38_30: +LBB34_31: BYTE $0x5b // popq %rbx WORD $0x5e41 // popq %r14 - WORD $0x5f41 // popq %r15 BYTE $0x5d // popq %rbp BYTE $0xc3 // retq -LBB38_13: - WORD $0x6349; BYTE $0xf3 // movslq %r11d, %rsi - WORD $0xff48; BYTE $0xce // decq %rsi - LONG $0x00001be9; BYTE $0x00 // jmp LBB38_14, $27(%rip) - LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 +LBB34_13: + WORD $0x6349; BYTE $0xf6 // movslq %r14d, %rsi + WORD $0xff48; BYTE $0xce // decq %rsi + LONG $0x000021e9; BYTE $0x00 // jmp LBB34_14, $33(%rip) + QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90 -LBB38_15: +LBB34_15: WORD $0x3004 // addb $48, %al WORD $0x8b48; BYTE $0x1f // movq (%rdi), %rbx WORD $0x0488; BYTE $0x33 // movb %al, (%rbx,%rsi) -LBB38_21: +LBB34_22: WORD $0xff48; BYTE $0xce // decq %rsi LONG $0x09f98348 // cmpq $9, %rcx - LONG $0xff6a860f; WORD $0xffff // jbe LBB38_22, $-150(%rip) + LONG $0xff6d860f; WORD $0xffff // jbe LBB34_23, $-147(%rip) -LBB38_14: +LBB34_14: WORD $0x8948; BYTE $0xd1 // movq %rdx, %rcx WORD $0x8948; BYTE $0xd0 // movq %rdx, %rax - WORD $0xf749; BYTE $0xe2 // mulq %r10 + WORD $0xf749; BYTE $0xe3 // mulq %r11 LONG $0x03eac148 // shrq $3, %rdx LONG $0x12048d48 // leaq (%rdx,%rdx), %rax LONG $0x801c8d48 // leaq (%rax,%rax,4), %rbx WORD $0x8948; BYTE $0xc8 // movq %rcx, %rax WORD $0x2948; BYTE $0xd8 // subq %rbx, %rax LONG $0x08773948 // cmpq %rsi, $8(%rdi) - LONG $0xffc6870f; WORD $0xffff // ja LBB38_15, $-58(%rip) + LONG $0xffc6870f; WORD $0xffff // ja LBB34_15, $-58(%rip) WORD $0x8548; BYTE $0xc0 // testq %rax, %rax - LONG $0xffc5840f; WORD $0xffff // je LBB38_21, $-59(%rip) + LONG $0xffc5840f; WORD $0xffff // je LBB34_22, $-59(%rip) LONG $0x011c47c7; WORD $0x0000; BYTE $0x00 // movl $1, $28(%rdi) - LONG $0xffffb9e9; BYTE $0xff // jmp LBB38_21, $-71(%rip) + LONG $0xffffb9e9; BYTE $0xff // jmp LBB34_22, $-71(%rip) -LBB38_3: - LONG $0xfe898c0f; WORD $0xffff // jl LBB38_7, $-375(%rip) - LONG $0xfffe87e9; BYTE $0xff // jmp LBB38_8, $-377(%rip) - LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 +LBB34_30: + LONG $0x001447c7; WORD $0x0000; BYTE $0x00 // movl $0, $20(%rdi) + BYTE $0x5b // popq %rbx + WORD $0x5e41 // popq %r14 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB34_5: + LONG $0xfe898c0f; WORD $0xffff // jl LBB34_7, $-375(%rip) + LONG $0xfffe87e9; BYTE $0xff // jmp LBB34_8, $-377(%rip) + QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90 _right_shift: BYTE $0x55 // pushq %rbp @@ -11374,26 +10986,25 @@ _right_shift: WORD $0xd231 // xorl %edx, %edx WORD $0x8545; BYTE $0xc0 // testl %r8d, %r8d LONG $0x0000bb41; WORD $0x0000 // movl $0, %r11d - LONG $0xd84f0f45 // cmovgl %r8d, %r11d + LONG $0xd8490f45 // cmovnsl %r8d, %r11d WORD $0xc031 // xorl %eax, %eax LONG $0x90909090 // .p2align 4, 0x90 -LBB39_1: +LBB35_1: WORD $0x3949; BYTE $0xd3 // cmpq %rdx, %r11 - LONG $0x0132840f; WORD $0x0000 // je LBB39_2, $306(%rip) + LONG $0x0132840f; WORD $0x0000 // je LBB35_2, $306(%rip) LONG $0x80048d48 // leaq (%rax,%rax,4), %rax WORD $0x8b48; BYTE $0x37 // movq (%rdi), %rsi LONG $0x34be0f48; BYTE $0x16 // movsbq (%rsi,%rdx), %rsi - LONG $0x46048d48 // leaq (%rsi,%rax,2), %rax - LONG $0xd0c08348 // addq $-48, %rax + LONG $0x46448d48; BYTE $0xd0 // leaq $-48(%rsi,%rax,2), %rax WORD $0xff48; BYTE $0xc2 // incq %rdx WORD $0x8948; BYTE $0xc6 // movq %rax, %rsi WORD $0xd348; BYTE $0xee // shrq %cl, %rsi WORD $0x8548; BYTE $0xf6 // testq %rsi, %rsi - LONG $0xffd1840f; WORD $0xffff // je LBB39_1, $-47(%rip) + LONG $0xffd4840f; WORD $0xffff // je LBB35_1, $-44(%rip) WORD $0x8941; BYTE $0xd3 // movl %edx, %r11d -LBB39_7: +LBB35_7: WORD $0x578b; BYTE $0x14 // movl $20(%rdi), %edx WORD $0x2944; BYTE $0xda // subl %r11d, %edx WORD $0xc2ff // incl %edx @@ -11403,608 +11014,339 @@ LBB39_7: WORD $0xf749; BYTE $0xd1 // notq %r9 WORD $0x3145; BYTE $0xd2 // xorl %r10d, %r10d WORD $0x3945; BYTE $0xc3 // cmpl %r8d, %r11d - LONG $0x00718d0f; WORD $0x0000 // jge LBB39_10, $113(%rip) + LONG $0x00648d0f; WORD $0x0000 // jge LBB35_10, $100(%rip) WORD $0x634d; BYTE $0xc3 // movslq %r11d, %r8 WORD $0x8b48; BYTE $0x37 // movq (%rdi), %rsi WORD $0x3145; BYTE $0xd2 // xorl %r10d, %r10d - BYTE $0x90 // .p2align 4, 0x90 + LONG $0x90909090 // .p2align 4, 0x90 -LBB39_9: - WORD $0x8948; BYTE $0xc2 // movq %rax, %rdx - WORD $0xd348; BYTE $0xea // shrq %cl, %rdx - WORD $0x214c; BYTE $0xc8 // andq %r9, %rax - WORD $0xc280; BYTE $0x30 // addb $48, %dl - LONG $0x16148842 // movb %dl, (%rsi,%r10) - WORD $0x8b48; BYTE $0x37 // movq (%rdi), %rsi - LONG $0x06148d4a // leaq (%rsi,%r8), %rdx - LONG $0x1cbe0f4d; BYTE $0x12 // movsbq (%r10,%rdx), %r11 - LONG $0x105c8d4b; BYTE $0x01 // leaq $1(%r8,%r10), %rbx - WORD $0xff49; BYTE $0xc2 // incq %r10 - LONG $0x80048d48 // leaq (%rax,%rax,4), %rax - LONG $0x43048d49 // leaq (%r11,%rax,2), %rax - LONG $0xd0c08348 // addq $-48, %rax - LONG $0x10576348 // movslq $16(%rdi), %rdx - WORD $0x3948; BYTE $0xd3 // cmpq %rdx, %rbx - LONG $0xffc38c0f; WORD $0xffff // jl LBB39_9, $-61(%rip) - LONG $0x000025e9; BYTE $0x00 // jmp LBB39_10, $37(%rip) - QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 +LBB35_9: + WORD $0x8948; BYTE $0xc2 // movq %rax, %rdx + WORD $0xd348; BYTE $0xea // shrq %cl, %rdx + WORD $0x214c; BYTE $0xc8 // andq %r9, %rax + WORD $0xc280; BYTE $0x30 // addb $48, %dl + LONG $0x16148842 // movb %dl, (%rsi,%r10) + WORD $0x8b48; BYTE $0x37 // movq (%rdi), %rsi + LONG $0x06148d4a // leaq (%rsi,%r8), %rdx + LONG $0x1cbe0f4d; BYTE $0x12 // movsbq (%r10,%rdx), %r11 + LONG $0x105c8d4b; BYTE $0x01 // leaq $1(%r8,%r10), %rbx + LONG $0x01528d4d // leaq $1(%r10), %r10 + LONG $0x80048d48 // leaq (%rax,%rax,4), %rax + LONG $0x43448d49; BYTE $0xd0 // leaq $-48(%r11,%rax,2), %rax + LONG $0x10576348 // movslq $16(%rdi), %rdx + WORD $0x3948; BYTE $0xd3 // cmpq %rdx, %rbx + LONG $0xffc58c0f; WORD $0xffff // jl LBB35_9, $-59(%rip) + LONG $0x000017e9; BYTE $0x00 // jmp LBB35_10, $23(%rip) -LBB39_12: + // .p2align 4, 0x90 +LBB35_12: LONG $0x30c68040 // addb $48, %sil WORD $0x8b48; BYTE $0x1f // movq (%rdi), %rbx LONG $0x13348840 // movb %sil, (%rbx,%rdx) WORD $0xc2ff // incl %edx WORD $0x8941; BYTE $0xd2 // movl %edx, %r10d -LBB39_15: +LBB35_15: WORD $0x0148; BYTE $0xc0 // addq %rax, %rax LONG $0x80048d48 // leaq (%rax,%rax,4), %rax -LBB39_10: +LBB35_10: WORD $0x8548; BYTE $0xc0 // testq %rax, %rax - LONG $0x002b840f; WORD $0x0000 // je LBB39_16, $43(%rip) + LONG $0x002b840f; WORD $0x0000 // je LBB35_16, $43(%rip) WORD $0x8948; BYTE $0xc6 // movq %rax, %rsi WORD $0xd348; BYTE $0xee // shrq %cl, %rsi WORD $0x214c; BYTE $0xc8 // andq %r9, %rax WORD $0x6349; BYTE $0xd2 // movslq %r10d, %rdx LONG $0x08573948 // cmpq %rdx, $8(%rdi) - LONG $0xffca870f; WORD $0xffff // ja LBB39_12, $-54(%rip) + LONG $0xffca870f; WORD $0xffff // ja LBB35_12, $-54(%rip) WORD $0x8548; BYTE $0xf6 // testq %rsi, %rsi - LONG $0xffd1840f; WORD $0xffff // je LBB39_15, $-47(%rip) + LONG $0xffd1840f; WORD $0xffff // je LBB35_15, $-47(%rip) LONG $0x011c47c7; WORD $0x0000; BYTE $0x00 // movl $1, $28(%rdi) - LONG $0xffffc5e9; BYTE $0xff // jmp LBB39_15, $-59(%rip) + LONG $0xffffc5e9; BYTE $0xff // jmp LBB35_15, $-59(%rip) + +LBB35_16: + LONG $0x10578944 // movl %r10d, $16(%rdi) + WORD $0x8545; BYTE $0xd2 // testl %r10d, %r10d + LONG $0x00378e0f; WORD $0x0000 // jle LBB35_20, $55(%rip) + WORD $0x8b48; BYTE $0x07 // movq (%rdi), %rax + WORD $0x8944; BYTE $0xd1 // movl %r10d, %ecx + WORD $0xff48; BYTE $0xc1 // incq %rcx + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 -LBB39_16: +LBB35_18: + WORD $0xff41; BYTE $0xca // decl %r10d + LONG $0x103c8042; BYTE $0x30 // cmpb $48, (%rax,%r10) + LONG $0x001a850f; WORD $0x0000 // jne LBB35_22, $26(%rip) LONG $0x10578944 // movl %r10d, $16(%rdi) + WORD $0xff48; BYTE $0xc9 // decq %rcx + LONG $0x01f98348 // cmpq $1, %rcx + LONG $0xffe18f0f; WORD $0xffff // jg LBB35_18, $-31(%rip) + +LBB35_20: WORD $0x8545; BYTE $0xd2 // testl %r10d, %r10d - LONG $0x00758e0f; WORD $0x0000 // jle LBB39_20, $117(%rip) - WORD $0x8b48; BYTE $0x07 // movq (%rdi), %rax - WORD $0x8944; BYTE $0xd1 // movl %r10d, %ecx - WORD $0x9090 // .p2align 4, 0x90 + LONG $0x0045840f; WORD $0x0000 // je LBB35_21, $69(%rip) -LBB39_18: - LONG $0xff518d48 // leaq $-1(%rcx), %rdx - WORD $0xd689 // movl %edx, %esi - LONG $0x30303c80 // cmpb $48, (%rax,%rsi) - LONG $0x0063850f; WORD $0x0000 // jne LBB39_22, $99(%rip) - WORD $0xc9ff // decl %ecx - WORD $0x4f89; BYTE $0x10 // movl %ecx, $16(%rdi) - LONG $0x01728d48 // leaq $1(%rdx), %rsi - WORD $0x8948; BYTE $0xd1 // movq %rdx, %rcx - LONG $0x01fe8348 // cmpq $1, %rsi - LONG $0xffda870f; WORD $0xffff // ja LBB39_18, $-38(%rip) - LONG $0x00004be9; BYTE $0x00 // jmp LBB39_21, $75(%rip) +LBB35_22: + BYTE $0x5b // popq %rbx + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq -LBB39_2: +LBB35_2: WORD $0x8548; BYTE $0xc0 // testq %rax, %rax - LONG $0x004c840f; WORD $0x0000 // je LBB39_23, $76(%rip) + LONG $0x0043840f; WORD $0x0000 // je LBB35_23, $67(%rip) QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90 WORD $0x8948; BYTE $0xc2 // movq %rax, %rdx WORD $0xd348; BYTE $0xea // shrq %cl, %rdx WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx - LONG $0xfed3850f; WORD $0xffff // jne LBB39_7, $-301(%rip) + LONG $0xfed0850f; WORD $0xffff // jne LBB35_7, $-304(%rip) -LBB39_4: +LBB35_4: WORD $0x0148; BYTE $0xc0 // addq %rax, %rax LONG $0x80048d48 // leaq (%rax,%rax,4), %rax WORD $0xff41; BYTE $0xc3 // incl %r11d WORD $0x8948; BYTE $0xc2 // movq %rax, %rdx WORD $0xd348; BYTE $0xea // shrq %cl, %rdx WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx - LONG $0xffe7840f; WORD $0xffff // je LBB39_4, $-25(%rip) - LONG $0xfffeb5e9; BYTE $0xff // jmp LBB39_7, $-331(%rip) + LONG $0xffe7840f; WORD $0xffff // je LBB35_4, $-25(%rip) + LONG $0xfffeb2e9; BYTE $0xff // jmp LBB35_7, $-334(%rip) -LBB39_20: - LONG $0x0003840f; WORD $0x0000 // je LBB39_21, $3(%rip) - -LBB39_22: - BYTE $0x5b // popq %rbx - BYTE $0x5d // popq %rbp - BYTE $0xc3 // retq - -LBB39_21: +LBB35_21: LONG $0x001447c7; WORD $0x0000; BYTE $0x00 // movl $0, $20(%rdi) BYTE $0x5b // popq %rbx BYTE $0x5d // popq %rbp BYTE $0xc3 // retq -LBB39_23: - LONG $0x001047c7; WORD $0x0000; BYTE $0x00 // movl $0, $16(%rdi) - BYTE $0x5b // popq %rbx - BYTE $0x5d // popq %rbp - BYTE $0xc3 // retq - QUAD $0x0000000000000000; QUAD $0x0000000000000000; LONG $0x00000000; WORD $0x0000 // .p2align 5, 0x00 +LBB35_23: + LONG $0x001047c7; WORD $0x0000; BYTE $0x00 // movl $0, $16(%rdi) + BYTE $0x5b // popq %rbx + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + QUAD $0x0000000000000000; LONG $0x00000000; WORD $0x0000; BYTE $0x00 // .p2align 5, 0x00 -LCPI40_0: +LCPI36_0: QUAD $0x2222222222222222; QUAD $0x2222222222222222 // .space 16, '""""""""""""""""' QUAD $0x2222222222222222; QUAD $0x2222222222222222 // .space 16, '""""""""""""""""' -LCPI40_1: +LCPI36_1: QUAD $0x5c5c5c5c5c5c5c5c; QUAD $0x5c5c5c5c5c5c5c5c // .space 16, '\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' QUAD $0x5c5c5c5c5c5c5c5c; QUAD $0x5c5c5c5c5c5c5c5c // .space 16, '\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' // .p2align 4, 0x90 _advance_string_default: - BYTE $0x55 // pushq %rbp - WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp - WORD $0x5741 // pushq %r15 - WORD $0x5641 // pushq %r14 - WORD $0x5541 // pushq %r13 - WORD $0x5441 // pushq %r12 - BYTE $0x53 // pushq %rbx - LONG $0x087f8b4c // movq $8(%rdi), %r15 - WORD $0x2949; BYTE $0xf7 // subq %rsi, %r15 - LONG $0x02e9840f; WORD $0x0000 // je LBB40_17, $745(%rip) - WORD $0x8b4c; BYTE $0x0f // movq (%rdi), %r9 - LONG $0xff02c748; WORD $0xffff; BYTE $0xff // movq $-1, (%rdx) - LONG $0x40ff8349 // cmpq $64, %r15 - LONG $0x0172820f; WORD $0x0000 // jb LBB40_18, $370(%rip) - WORD $0x8948; BYTE $0xf7 // movq %rsi, %rdi - WORD $0xf748; BYTE $0xd7 // notq %rdi - LONG $0xffc0c749; WORD $0xffff; BYTE $0xff // movq $-1, %r8 - WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d - QUAD $0xffffff7a056ffdc5 // vmovdqa $-134(%rip), %ymm0 /* LCPI40_0(%rip) */ - QUAD $0xffffff920d6ffdc5 // vmovdqa $-110(%rip), %ymm1 /* LCPI40_1(%rip) */ - QUAD $0xaaaaaaaaaaaaba49; WORD $0xaaaa // movabsq $-6148914691236517206, %r10 - QUAD $0x555555555555bb49; WORD $0x5555 // movabsq $6148914691236517205, %r11 - QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 - -LBB40_3: - LONG $0x6f7ec1c4; WORD $0x3114 // vmovdqu (%r9,%rsi), %ymm2 - LONG $0x6f7ec1c4; WORD $0x315c; BYTE $0x20 // vmovdqu $32(%r9,%rsi), %ymm3 - LONG $0xe074edc5 // vpcmpeqb %ymm0, %ymm2, %ymm4 - LONG $0xe4d77dc5 // vpmovmskb %ymm4, %r12d - LONG $0xe074e5c5 // vpcmpeqb %ymm0, %ymm3, %ymm4 - LONG $0xccd7fdc5 // vpmovmskb %ymm4, %ecx - LONG $0xd174edc5 // vpcmpeqb %ymm1, %ymm2, %ymm2 - LONG $0xc2d7fdc5 // vpmovmskb %ymm2, %eax - LONG $0xd174e5c5 // vpcmpeqb %ymm1, %ymm3, %ymm2 - LONG $0xdad7fdc5 // vpmovmskb %ymm2, %ebx - LONG $0x20e1c148 // shlq $32, %rcx - WORD $0x0949; BYTE $0xcc // orq %rcx, %r12 - LONG $0x20e3c148 // shlq $32, %rbx - WORD $0x0948; BYTE $0xd8 // orq %rbx, %rax - LONG $0x0030850f; WORD $0x0000 // jne LBB40_7, $48(%rip) - WORD $0x854d; BYTE $0xf6 // testq %r14, %r14 - LONG $0x003b850f; WORD $0x0000 // jne LBB40_9, $59(%rip) + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5741 // pushq %r15 + WORD $0x5641 // pushq %r14 + WORD $0x5441 // pushq %r12 + BYTE $0x53 // pushq %rbx + LONG $0x087f8b4c // movq $8(%rdi), %r15 + WORD $0x2949; BYTE $0xf7 // subq %rsi, %r15 + LONG $0x028e840f; WORD $0x0000 // je LBB36_16, $654(%rip) + WORD $0x8b4c; BYTE $0x1f // movq (%rdi), %r11 + WORD $0x014c; BYTE $0xde // addq %r11, %rsi + LONG $0xff02c748; WORD $0xffff; BYTE $0xff // movq $-1, (%rdx) + LONG $0xffc0c749; WORD $0xffff; BYTE $0xff // movq $-1, %r8 WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d - WORD $0x854d; BYTE $0xe4 // testq %r12, %r12 - LONG $0x006d850f; WORD $0x0000 // jne LBB40_10, $109(%rip) + LONG $0x40ff8349 // cmpq $64, %r15 + LONG $0x00ed820f; WORD $0x0000 // jb LBB36_10, $237(%rip) + QUAD $0xffffff7f056ffdc5 // vmovdqa $-129(%rip), %ymm0 /* LCPI36_0(%rip) */ + QUAD $0xffffff970d6ffdc5 // vmovdqa $-105(%rip), %ymm1 /* LCPI36_1(%rip) */ + QUAD $0xaaaaaaaaaaaab949; WORD $0xaaaa // movabsq $-6148914691236517206, %r9 + QUAD $0x555555555555ba49; WORD $0x5555 // movabsq $6148914691236517205, %r10 + WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 -LBB40_6: - LONG $0xc0c78349 // addq $-64, %r15 - LONG $0xc0c78348 // addq $-64, %rdi +LBB36_3: + LONG $0x166ffec5 // vmovdqu (%rsi), %ymm2 + LONG $0x5e6ffec5; BYTE $0x20 // vmovdqu $32(%rsi), %ymm3 + LONG $0xe074edc5 // vpcmpeqb %ymm0, %ymm2, %ymm4 + LONG $0xfcd7fdc5 // vpmovmskb %ymm4, %edi + LONG $0xe074e5c5 // vpcmpeqb %ymm0, %ymm3, %ymm4 + LONG $0xc4d7fdc5 // vpmovmskb %ymm4, %eax + LONG $0xd174edc5 // vpcmpeqb %ymm1, %ymm2, %ymm2 + LONG $0xdad7fdc5 // vpmovmskb %ymm2, %ebx + LONG $0xd174e5c5 // vpcmpeqb %ymm1, %ymm3, %ymm2 + LONG $0xcad7fdc5 // vpmovmskb %ymm2, %ecx + LONG $0x20e0c148 // shlq $32, %rax + WORD $0x0948; BYTE $0xc7 // orq %rax, %rdi + LONG $0x20e1c148 // shlq $32, %rcx + WORD $0x0948; BYTE $0xcb // orq %rcx, %rbx + LONG $0x002c850f; WORD $0x0000 // jne LBB36_7, $44(%rip) + WORD $0x854d; BYTE $0xf6 // testq %r14, %r14 + LONG $0x003d850f; WORD $0x0000 // jne LBB36_9, $61(%rip) + WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d + WORD $0x8548; BYTE $0xff // testq %rdi, %rdi + LONG $0x00b7850f; WORD $0x0000 // jne LBB36_14, $183(%rip) + +LBB36_6: LONG $0x40c68348 // addq $64, %rsi + LONG $0xc0c78349 // addq $-64, %r15 LONG $0x3fff8349 // cmpq $63, %r15 - LONG $0xff94870f; WORD $0xffff // ja LBB40_3, $-108(%rip) - LONG $0x000067e9; BYTE $0x00 // jmp LBB40_12, $103(%rip) + LONG $0xff9c870f; WORD $0xffff // ja LBB36_3, $-100(%rip) + LONG $0x00005de9; BYTE $0x00 // jmp LBB36_10, $93(%rip) -LBB40_7: +LBB36_7: LONG $0xfff88349 // cmpq $-1, %r8 - LONG $0x000a850f; WORD $0x0000 // jne LBB40_9, $10(%rip) - LONG $0xc0bc0f4c // bsfq %rax, %r8 - WORD $0x0149; BYTE $0xf0 // addq %rsi, %r8 + LONG $0x0010850f; WORD $0x0000 // jne LBB36_9, $16(%rip) + WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax + WORD $0x294c; BYTE $0xd8 // subq %r11, %rax + LONG $0xc3bc0f4c // bsfq %rbx, %r8 + WORD $0x0149; BYTE $0xc0 // addq %rax, %r8 WORD $0x894c; BYTE $0x02 // movq %r8, (%rdx) -LBB40_9: - WORD $0x894c; BYTE $0xf1 // movq %r14, %rcx +LBB36_9: + WORD $0x894c; BYTE $0xf0 // movq %r14, %rax + WORD $0xf748; BYTE $0xd0 // notq %rax + WORD $0x2148; BYTE $0xd8 // andq %rbx, %rax + LONG $0x00248d4c // leaq (%rax,%rax), %r12 + WORD $0x094d; BYTE $0xf4 // orq %r14, %r12 + WORD $0x894c; BYTE $0xe1 // movq %r12, %rcx WORD $0xf748; BYTE $0xd1 // notq %rcx - WORD $0x2148; BYTE $0xc1 // andq %rax, %rcx - LONG $0x092c8d4c // leaq (%rcx,%rcx), %r13 - WORD $0x094d; BYTE $0xf5 // orq %r14, %r13 - WORD $0x894c; BYTE $0xeb // movq %r13, %rbx - WORD $0xf748; BYTE $0xd3 // notq %rbx - WORD $0x2148; BYTE $0xc3 // andq %rax, %rbx - WORD $0x214c; BYTE $0xd3 // andq %r10, %rbx + WORD $0x2148; BYTE $0xd9 // andq %rbx, %rcx + WORD $0x214c; BYTE $0xc9 // andq %r9, %rcx WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d - WORD $0x0148; BYTE $0xcb // addq %rcx, %rbx + WORD $0x0148; BYTE $0xc1 // addq %rax, %rcx LONG $0xc6920f41 // setb %r14b - WORD $0x0148; BYTE $0xdb // addq %rbx, %rbx - WORD $0x314c; BYTE $0xdb // xorq %r11, %rbx - WORD $0x214c; BYTE $0xeb // andq %r13, %rbx - WORD $0xf748; BYTE $0xd3 // notq %rbx - WORD $0x2149; BYTE $0xdc // andq %rbx, %r12 - WORD $0x854d; BYTE $0xe4 // testq %r12, %r12 - LONG $0xff93840f; WORD $0xffff // je LBB40_6, $-109(%rip) - -LBB40_10: - LONG $0xc4bc0f49 // bsfq %r12, %rax - WORD $0x2948; BYTE $0xf8 // subq %rdi, %rax - -LBB40_11: - BYTE $0x5b // popq %rbx - WORD $0x5c41 // popq %r12 - WORD $0x5d41 // popq %r13 - WORD $0x5e41 // popq %r14 - WORD $0x5f41 // popq %r15 - BYTE $0x5d // popq %rbp - WORD $0xf8c5; BYTE $0x77 // vzeroupper - BYTE $0xc3 // retq + WORD $0x0148; BYTE $0xc9 // addq %rcx, %rcx + WORD $0x314c; BYTE $0xd1 // xorq %r10, %rcx + WORD $0x214c; BYTE $0xe1 // andq %r12, %rcx + WORD $0xf748; BYTE $0xd1 // notq %rcx + WORD $0x2148; BYTE $0xcf // andq %rcx, %rdi + WORD $0x8548; BYTE $0xff // testq %rdi, %rdi + LONG $0xff91840f; WORD $0xffff // je LBB36_6, $-111(%rip) + LONG $0x000043e9; BYTE $0x00 // jmp LBB36_14, $67(%rip) -LBB40_12: - WORD $0x014c; BYTE $0xce // addq %r9, %rsi +LBB36_10: LONG $0x20ff8349 // cmpq $32, %r15 - LONG $0x00c2820f; WORD $0x0000 // jb LBB40_23, $194(%rip) - -LBB40_13: + LONG $0x00ac820f; WORD $0x0000 // jb LBB36_21, $172(%rip) LONG $0x066ffec5 // vmovdqu (%rsi), %ymm0 - QUAD $0xfffffe5f0d74fdc5 // vpcmpeqb $-417(%rip), %ymm0, %ymm1 /* LCPI40_0(%rip) */ + QUAD $0xfffffe840d74fdc5 // vpcmpeqb $-380(%rip), %ymm0, %ymm1 /* LCPI36_0(%rip) */ LONG $0xf9d7fdc5 // vpmovmskb %ymm1, %edi - QUAD $0xfffffe730574fdc5 // vpcmpeqb $-397(%rip), %ymm0, %ymm0 /* LCPI40_1(%rip) */ - LONG $0xc0d7fdc5 // vpmovmskb %ymm0, %eax - WORD $0xc085 // testl %eax, %eax - LONG $0x0043850f; WORD $0x0000 // jne LBB40_19, $67(%rip) + QUAD $0xfffffe980574fdc5 // vpcmpeqb $-360(%rip), %ymm0, %ymm0 /* LCPI36_1(%rip) */ + LONG $0xd8d7fdc5 // vpmovmskb %ymm0, %ebx + WORD $0xdb85 // testl %ebx, %ebx + LONG $0x002d850f; WORD $0x0000 // jne LBB36_17, $45(%rip) WORD $0x854d; BYTE $0xf6 // testq %r14, %r14 - LONG $0x0054850f; WORD $0x0000 // jne LBB40_21, $84(%rip) + LONG $0x003e850f; WORD $0x0000 // jne LBB36_19, $62(%rip) WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d WORD $0x8548; BYTE $0xff // testq %rdi, %rdi - LONG $0x0081840f; WORD $0x0000 // je LBB40_22, $129(%rip) + LONG $0x006b840f; WORD $0x0000 // je LBB36_20, $107(%rip) -LBB40_16: +LBB36_14: LONG $0xc7bc0f48 // bsfq %rdi, %rax - WORD $0x294c; BYTE $0xce // subq %r9, %rsi - WORD $0x0148; BYTE $0xf0 // addq %rsi, %rax - WORD $0xff48; BYTE $0xc0 // incq %rax - LONG $0xffff9ae9; BYTE $0xff // jmp LBB40_11, $-102(%rip) + WORD $0x294c; BYTE $0xde // subq %r11, %rsi + LONG $0x06448d48; BYTE $0x01 // leaq $1(%rsi,%rax), %rax -LBB40_18: - WORD $0x014c; BYTE $0xce // addq %r9, %rsi - LONG $0xffc0c749; WORD $0xffff; BYTE $0xff // movq $-1, %r8 - WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d - LONG $0x20ff8349 // cmpq $32, %r15 - LONG $0xff9e830f; WORD $0xffff // jae LBB40_13, $-98(%rip) - LONG $0x00005be9; BYTE $0x00 // jmp LBB40_23, $91(%rip) +LBB36_15: + BYTE $0x5b // popq %rbx + WORD $0x5c41 // popq %r12 + WORD $0x5e41 // popq %r14 + WORD $0x5f41 // popq %r15 + BYTE $0x5d // popq %rbp + WORD $0xf8c5; BYTE $0x77 // vzeroupper + BYTE $0xc3 // retq -LBB40_19: +LBB36_17: LONG $0xfff88349 // cmpq $-1, %r8 - LONG $0x0010850f; WORD $0x0000 // jne LBB40_21, $16(%rip) - WORD $0x8948; BYTE $0xf1 // movq %rsi, %rcx - WORD $0x294c; BYTE $0xc9 // subq %r9, %rcx - LONG $0xc0bc0f4c // bsfq %rax, %r8 - WORD $0x0149; BYTE $0xc8 // addq %rcx, %r8 + LONG $0x0010850f; WORD $0x0000 // jne LBB36_19, $16(%rip) + WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax + WORD $0x294c; BYTE $0xd8 // subq %r11, %rax + LONG $0xc3bc0f4c // bsfq %rbx, %r8 + WORD $0x0149; BYTE $0xc0 // addq %rax, %r8 WORD $0x894c; BYTE $0x02 // movq %r8, (%rdx) -LBB40_21: - WORD $0x8944; BYTE $0xf1 // movl %r14d, %ecx +LBB36_19: + WORD $0x8944; BYTE $0xf0 // movl %r14d, %eax + WORD $0xd0f7 // notl %eax + WORD $0xd821 // andl %ebx, %eax + WORD $0x0c8d; BYTE $0x00 // leal (%rax,%rax), %ecx + LONG $0x460c8d45 // leal (%r14,%rax,2), %r9d WORD $0xd1f7 // notl %ecx - WORD $0xc121 // andl %eax, %ecx - WORD $0x1c8d; BYTE $0x09 // leal (%rcx,%rcx), %ebx - LONG $0x4e148d45 // leal (%r14,%rcx,2), %r10d - WORD $0xd3f7 // notl %ebx - WORD $0xc321 // andl %eax, %ebx - LONG $0xaaaae381; WORD $0xaaaa // andl $-1431655766, %ebx + WORD $0xd921 // andl %ebx, %ecx + LONG $0xaaaae181; WORD $0xaaaa // andl $-1431655766, %ecx WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d - WORD $0xcb01 // addl %ecx, %ebx + WORD $0xc101 // addl %eax, %ecx LONG $0xc6920f41 // setb %r14b - WORD $0xdb01 // addl %ebx, %ebx - LONG $0x5555f381; WORD $0x5555 // xorl $1431655765, %ebx - WORD $0x2144; BYTE $0xd3 // andl %r10d, %ebx - WORD $0xd3f7 // notl %ebx - WORD $0xdf21 // andl %ebx, %edi + WORD $0xc901 // addl %ecx, %ecx + LONG $0x5555f181; WORD $0x5555 // xorl $1431655765, %ecx + WORD $0x2144; BYTE $0xc9 // andl %r9d, %ecx + WORD $0xd1f7 // notl %ecx + WORD $0xcf21 // andl %ecx, %edi WORD $0x8548; BYTE $0xff // testq %rdi, %rdi - LONG $0xff7f850f; WORD $0xffff // jne LBB40_16, $-129(%rip) + LONG $0xff95850f; WORD $0xffff // jne LBB36_14, $-107(%rip) -LBB40_22: +LBB36_20: LONG $0x20c68348 // addq $32, %rsi LONG $0xe0c78349 // addq $-32, %r15 -LBB40_23: - WORD $0x854d; BYTE $0xf6 // testq %r14, %r14 - LONG $0x00b0850f; WORD $0x0000 // jne LBB40_38, $176(%rip) - WORD $0x854d; BYTE $0xff // testq %r15, %r15 - LONG $0x0083840f; WORD $0x0000 // je LBB40_35, $131(%rip) - -LBB40_25: - WORD $0x894d; BYTE $0xca // movq %r9, %r10 - WORD $0xf749; BYTE $0xda // negq %r10 +LBB36_21: + WORD $0x854d; BYTE $0xf6 // testq %r14, %r14 + LONG $0x0087850f; WORD $0x0000 // jne LBB36_32, $135(%rip) LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax + WORD $0x854d; BYTE $0xff // testq %r15, %r15 + LONG $0xff80840f; WORD $0xffff // je LBB36_15, $-128(%rip) -LBB40_26: - WORD $0xdb31 // xorl %ebx, %ebx - -LBB40_27: - LONG $0x1e3cb60f // movzbl (%rsi,%rbx), %edi - WORD $0xff83; BYTE $0x22 // cmpl $34, %edi - LONG $0x0061840f; WORD $0x0000 // je LBB40_34, $97(%rip) - WORD $0xff83; BYTE $0x5c // cmpl $92, %edi - LONG $0x0011840f; WORD $0x0000 // je LBB40_30, $17(%rip) - WORD $0xff48; BYTE $0xc3 // incq %rbx - WORD $0x3949; BYTE $0xdf // cmpq %rbx, %r15 - LONG $0xffde850f; WORD $0xffff // jne LBB40_27, $-34(%rip) - LONG $0x000058e9; BYTE $0x00 // jmp LBB40_36, $88(%rip) +LBB36_23: + WORD $0x894d; BYTE $0xd9 // movq %r11, %r9 + WORD $0xf749; BYTE $0xd1 // notq %r9 + +LBB36_24: + LONG $0x017e8d48 // leaq $1(%rsi), %rdi + WORD $0xb60f; BYTE $0x1e // movzbl (%rsi), %ebx + WORD $0xfb80; BYTE $0x22 // cmpb $34, %bl + LONG $0x0056840f; WORD $0x0000 // je LBB36_31, $86(%rip) + LONG $0xff578d4d // leaq $-1(%r15), %r10 + WORD $0xfb80; BYTE $0x5c // cmpb $92, %bl + LONG $0x0014840f; WORD $0x0000 // je LBB36_27, $20(%rip) + WORD $0x894d; BYTE $0xd7 // movq %r10, %r15 + WORD $0x8948; BYTE $0xfe // movq %rdi, %rsi + WORD $0x854d; BYTE $0xd2 // testq %r10, %r10 + LONG $0xffd4850f; WORD $0xffff // jne LBB36_24, $-44(%rip) + LONG $0xffff49e9; BYTE $0xff // jmp LBB36_15, $-183(%rip) -LBB40_30: - LONG $0xff4f8d49 // leaq $-1(%r15), %rcx - WORD $0x3948; BYTE $0xd9 // cmpq %rbx, %rcx - LONG $0xfece840f; WORD $0xffff // je LBB40_11, $-306(%rip) +LBB36_27: + WORD $0x854d; BYTE $0xd2 // testq %r10, %r10 + LONG $0xff40840f; WORD $0xffff // je LBB36_15, $-192(%rip) LONG $0xfff88349 // cmpq $-1, %r8 - LONG $0x000a850f; WORD $0x0000 // jne LBB40_33, $10(%rip) - LONG $0x32048d4d // leaq (%r10,%rsi), %r8 - WORD $0x0149; BYTE $0xd8 // addq %rbx, %r8 - WORD $0x894c; BYTE $0x02 // movq %r8, (%rdx) + LONG $0x0009850f; WORD $0x0000 // jne LBB36_30, $9(%rip) + WORD $0x014c; BYTE $0xcf // addq %r9, %rdi + WORD $0x8948; BYTE $0x3a // movq %rdi, (%rdx) + WORD $0x8949; BYTE $0xf8 // movq %rdi, %r8 -LBB40_33: - WORD $0x0148; BYTE $0xde // addq %rbx, %rsi +LBB36_30: LONG $0x02c68348 // addq $2, %rsi - WORD $0x894c; BYTE $0xf9 // movq %r15, %rcx - WORD $0x2948; BYTE $0xd9 // subq %rbx, %rcx - LONG $0xfec18348 // addq $-2, %rcx LONG $0xfec78349 // addq $-2, %r15 - WORD $0x3949; BYTE $0xdf // cmpq %rbx, %r15 - WORD $0x8949; BYTE $0xcf // movq %rcx, %r15 - LONG $0xff95850f; WORD $0xffff // jne LBB40_26, $-107(%rip) - LONG $0xfffe94e9; BYTE $0xff // jmp LBB40_11, $-364(%rip) - -LBB40_34: - WORD $0x0148; BYTE $0xde // addq %rbx, %rsi - WORD $0xff48; BYTE $0xc6 // incq %rsi - -LBB40_35: - WORD $0x294c; BYTE $0xce // subq %r9, %rsi - WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax - LONG $0xfffe83e9; BYTE $0xff // jmp LBB40_11, $-381(%rip) + WORD $0x894d; BYTE $0xfa // movq %r15, %r10 + WORD $0x854d; BYTE $0xd2 // testq %r10, %r10 + LONG $0xff9f850f; WORD $0xffff // jne LBB36_24, $-97(%rip) + LONG $0xffff14e9; BYTE $0xff // jmp LBB36_15, $-236(%rip) -LBB40_36: - LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax - LONG $0x22ff8040 // cmpb $34, %dil - LONG $0xfe72850f; WORD $0xffff // jne LBB40_11, $-398(%rip) - WORD $0x0148; BYTE $0xde // addq %rbx, %rsi - LONG $0xffffdce9; BYTE $0xff // jmp LBB40_35, $-36(%rip) +LBB36_31: + WORD $0x294c; BYTE $0xdf // subq %r11, %rdi + WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax + LONG $0xffff09e9; BYTE $0xff // jmp LBB36_15, $-247(%rip) -LBB40_38: +LBB36_32: WORD $0x854d; BYTE $0xff // testq %r15, %r15 - LONG $0x002a840f; WORD $0x0000 // je LBB40_17, $42(%rip) + LONG $0x0031840f; WORD $0x0000 // je LBB36_16, $49(%rip) LONG $0xfff88349 // cmpq $-1, %r8 - LONG $0x000c850f; WORD $0x0000 // jne LBB40_41, $12(%rip) - WORD $0x894d; BYTE $0xc8 // movq %r9, %r8 + LONG $0x000c850f; WORD $0x0000 // jne LBB36_35, $12(%rip) + WORD $0x894d; BYTE $0xd8 // movq %r11, %r8 WORD $0xf749; BYTE $0xd0 // notq %r8 WORD $0x0149; BYTE $0xf0 // addq %rsi, %r8 WORD $0x894c; BYTE $0x02 // movq %r8, (%rdx) -LBB40_41: - WORD $0xff48; BYTE $0xc6 // incq %rsi - WORD $0xff49; BYTE $0xcf // decq %r15 - WORD $0x854d; BYTE $0xff // testq %r15, %r15 - LONG $0xff2b850f; WORD $0xffff // jne LBB40_25, $-213(%rip) - LONG $0xffffa9e9; BYTE $0xff // jmp LBB40_35, $-87(%rip) - -LBB40_17: +LBB36_35: + WORD $0xff48; BYTE $0xc6 // incq %rsi + WORD $0xff49; BYTE $0xcf // decq %r15 LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax - LONG $0xfffe2be9; BYTE $0xff // jmp LBB40_11, $-469(%rip) - BYTE $0x00 // .p2align 4, 0x00 - -LCPI41_0: - BYTE $0xf0 // .byte 240 - BYTE $0x80 // .byte 128 - BYTE $0x80 // .byte 128 - BYTE $0x80 // .byte 128 - BYTE $0x00 // .space 1, '\x00' - BYTE $0x00 // .space 1, '\x00' - BYTE $0x00 // .space 1, '\x00' - BYTE $0x00 // .space 1, '\x00' - BYTE $0x00 // .space 1, '\x00' - BYTE $0x00 // .space 1, '\x00' - BYTE $0x00 // .space 1, '\x00' - BYTE $0x00 // .space 1, '\x00' - BYTE $0x00 // .space 1, '\x00' - BYTE $0x00 // .space 1, '\x00' - BYTE $0x00 // .space 1, '\x00' - BYTE $0x00 // .space 1, '\x00' - - // .p2align 4, 0x90 -_unescape: - BYTE $0x55 // pushq %rbp - WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp - WORD $0x5741 // pushq %r15 - WORD $0x5641 // pushq %r14 - WORD $0x5541 // pushq %r13 - WORD $0x5441 // pushq %r12 - BYTE $0x53 // pushq %rbx - LONG $0x18ec8348 // subq $24, %rsp - WORD $0x8b4c; BYTE $0x2f // movq (%rdi), %r13 - WORD $0x294c; BYTE $0xee // subq %r13, %rsi - LONG $0xffc3c748; WORD $0xffff; BYTE $0xff // movq $-1, %rbx - WORD $0x8548; BYTE $0xf6 // testq %rsi, %rsi - LONG $0x00d38e0f; WORD $0x0000 // jle LBB41_13, $211(%rip) - WORD $0x8949; BYTE $0xd6 // movq %rdx, %r14 - WORD $0x8949; BYTE $0xff // movq %rdi, %r15 - LONG $0x01458d49 // leaq $1(%r13), %rax - LONG $0x4db60f41; BYTE $0x01 // movzbl $1(%r13), %ecx - LONG $0x53158d48; WORD $0x0077; BYTE $0x00 // leaq $30547(%rip), %rdx /* __UnquoteTab(%rip) */ - LONG $0x110cb60f // movzbl (%rcx,%rdx), %ecx - LONG $0x00fff981; WORD $0x0000 // cmpl $255, %ecx - LONG $0x0017840f; WORD $0x0000 // je LBB41_4, $23(%rip) - WORD $0xc985 // testl %ecx, %ecx - LONG $0x0021850f; WORD $0x0000 // jne LBB41_6, $33(%rip) - WORD $0x8949; BYTE $0x07 // movq %rax, (%r15) - LONG $0xfdc3c748; WORD $0xffff; BYTE $0xff // movq $-3, %rbx - LONG $0x000096e9; BYTE $0x00 // jmp LBB41_13, $150(%rip) - -LBB41_4: - LONG $0x03fe8348 // cmpq $3, %rsi - LONG $0x0019870f; WORD $0x0000 // ja LBB41_7, $25(%rip) - WORD $0x8949; BYTE $0x07 // movq %rax, (%r15) - LONG $0x000084e9; BYTE $0x00 // jmp LBB41_13, $132(%rip) - -LBB41_6: - WORD $0x8841; BYTE $0x0e // movb %cl, (%r14) - LONG $0x02078349 // addq $2, (%r15) - LONG $0x000001bb; BYTE $0x00 // movl $1, %ebx - LONG $0x000073e9; BYTE $0x00 // jmp LBB41_13, $115(%rip) - -LBB41_7: - LONG $0x024d8b41 // movl $2(%r13), %ecx - WORD $0xc889 // movl %ecx, %eax - WORD $0xd0f7 // notl %eax - LONG $0xcfd0918d; WORD $0xcfcf // leal $-808464432(%rcx), %edx - LONG $0x80808025; BYTE $0x80 // andl $-2139062144, %eax - WORD $0xd085 // testl %edx, %eax - LONG $0x004a850f; WORD $0x0000 // jne LBB41_11, $74(%rip) - LONG $0x1919918d; WORD $0x1919 // leal $421075225(%rcx), %edx - WORD $0xca09 // orl %ecx, %edx - LONG $0x8080c2f7; WORD $0x8080 // testl $-2139062144, %edx - LONG $0x0036850f; WORD $0x0000 // jne LBB41_11, $54(%rip) - WORD $0xca89 // movl %ecx, %edx - LONG $0x7f7fe281; WORD $0x7f7f // andl $2139062143, %edx - LONG $0xc0c0c0bf; BYTE $0xc0 // movl $-1061109568, %edi - WORD $0xd729 // subl %edx, %edi - LONG $0x46469a8d; WORD $0x4646 // leal $1179010630(%rdx), %ebx - WORD $0xc721 // andl %eax, %edi - WORD $0xdf85 // testl %ebx, %edi - LONG $0x0017850f; WORD $0x0000 // jne LBB41_11, $23(%rip) - LONG $0xe0e0e0bf; BYTE $0xe0 // movl $-522133280, %edi - WORD $0xd729 // subl %edx, %edi - LONG $0x3939c281; WORD $0x3939 // addl $960051513, %edx - WORD $0xf821 // andl %edi, %eax - WORD $0xd085 // testl %edx, %eax - LONG $0x0020840f; WORD $0x0000 // je LBB41_14, $32(%rip) - -LBB41_11: - LONG $0x02c58349 // addq $2, %r13 - WORD $0x894d; BYTE $0x2f // movq %r13, (%r15) - -LBB41_12: - LONG $0xfec3c748; WORD $0xffff; BYTE $0xff // movq $-2, %rbx - -LBB41_13: - WORD $0x8948; BYTE $0xd8 // movq %rbx, %rax - LONG $0x18c48348 // addq $24, %rsp - BYTE $0x5b // popq %rbx - WORD $0x5c41 // popq %r12 - WORD $0x5d41 // popq %r13 - WORD $0x5e41 // popq %r14 - WORD $0x5f41 // popq %r15 - BYTE $0x5d // popq %rbp - BYTE $0xc3 // retq + WORD $0x854d; BYTE $0xff // testq %r15, %r15 + LONG $0xff54850f; WORD $0xffff // jne LBB36_23, $-172(%rip) + LONG $0xfffecfe9; BYTE $0xff // jmp LBB36_15, $-305(%rip) -LBB41_14: - WORD $0xc90f // bswapl %ecx - WORD $0xc889 // movl %ecx, %eax - WORD $0xd0f7 // notl %eax - WORD $0xe8c1; BYTE $0x04 // shrl $4, %eax - LONG $0x01010125; BYTE $0x01 // andl $16843009, %eax - WORD $0x048d; BYTE $0xc0 // leal (%rax,%rax,8), %eax - LONG $0x0f0fe181; WORD $0x0f0f // andl $252645135, %ecx - WORD $0xc101 // addl %eax, %ecx - WORD $0xc889 // movl %ecx, %eax - WORD $0xe8c1; BYTE $0x04 // shrl $4, %eax - WORD $0xc809 // orl %ecx, %eax - WORD $0xc189 // movl %eax, %ecx - WORD $0xe9c1; BYTE $0x08 // shrl $8, %ecx - LONG $0xff00e181; WORD $0x0000 // andl $65280, %ecx - LONG $0xe0b60f44 // movzbl %al, %r12d - WORD $0x0941; BYTE $0xcc // orl %ecx, %r12d - LONG $0x06558d49 // leaq $6(%r13), %rdx - WORD $0x8949; BYTE $0x17 // movq %rdx, (%r15) - LONG $0x7ffc8341 // cmpl $127, %r12d - LONG $0x004c860f; WORD $0x0000 // jbe LBB41_18, $76(%rip) - LONG $0xfffc8141; WORD $0x0007; BYTE $0x00 // cmpl $2047, %r12d - LONG $0x004c860f; WORD $0x0000 // jbe LBB41_19, $76(%rip) - QUAD $0xffff200024bc8d41 // leal $-57344(%r12), %edi - LONG $0xf7ffff81; WORD $0xffff // cmpl $-2049, %edi - LONG $0x0055870f; WORD $0x0000 // ja LBB41_20, $85(%rip) - WORD $0xe9c1; BYTE $0x0c // shrl $12, %ecx - WORD $0xc980; BYTE $0xe0 // orb $-32, %cl - WORD $0x8841; BYTE $0x0e // movb %cl, (%r14) - LONG $0x06ecc141 // shrl $6, %r12d - LONG $0x3fe48041 // andb $63, %r12b - LONG $0x80cc8041 // orb $-128, %r12b - LONG $0x01668845 // movb %r12b, $1(%r14) - WORD $0x3f24 // andb $63, %al - WORD $0x800c // orb $-128, %al - LONG $0x02468841 // movb %al, $2(%r14) - LONG $0x000003bb; BYTE $0x00 // movl $3, %ebx - LONG $0xffff5fe9; BYTE $0xff // jmp LBB41_13, $-161(%rip) - -LBB41_18: - WORD $0x8841; BYTE $0x06 // movb %al, (%r14) - LONG $0x000001bb; BYTE $0x00 // movl $1, %ebx - LONG $0xffff52e9; BYTE $0xff // jmp LBB41_13, $-174(%rip) - -LBB41_19: - LONG $0x06ecc141 // shrl $6, %r12d - LONG $0xc0cc8041 // orb $-64, %r12b - WORD $0x8845; BYTE $0x26 // movb %r12b, (%r14) - WORD $0x3f24 // andb $63, %al - WORD $0x800c // orb $-128, %al - LONG $0x01468841 // movb %al, $1(%r14) - LONG $0x000002bb; BYTE $0x00 // movl $2, %ebx - LONG $0xffff35e9; BYTE $0xff // jmp LBB41_13, $-203(%rip) - -LBB41_20: - LONG $0xfcc3c748; WORD $0xffff; BYTE $0xff // movq $-4, %rbx - LONG $0x06fe8348 // cmpq $6, %rsi - LONG $0xff24820f; WORD $0xffff // jb LBB41_13, $-220(%rip) - LONG $0xfffc8141; WORD $0x00db; BYTE $0x00 // cmpl $56319, %r12d - LONG $0xff17870f; WORD $0xffff // ja LBB41_13, $-233(%rip) - WORD $0x3a80; BYTE $0x5c // cmpb $92, (%rdx) - LONG $0xff0e850f; WORD $0xffff // jne LBB41_13, $-242(%rip) - LONG $0x077d8041; BYTE $0x75 // cmpb $117, $7(%r13) - LONG $0xff03850f; WORD $0xffff // jne LBB41_13, $-253(%rip) - LONG $0x08458d49 // leaq $8(%r13), %rax - LONG $0xc8458948 // movq %rax, $-56(%rbp) - LONG $0x087d8b41 // movl $8(%r13), %edi - WORD $0x7d89; BYTE $0xd4 // movl %edi, $-44(%rbp) - LONG $0xff89b5e8; BYTE $0xff // callq _unhex16_is, $-30283(%rip) - WORD $0xc084 // testb %al, %al - LONG $0x004f840f; WORD $0x0000 // je LBB41_27, $79(%rip) - WORD $0x4d8b; BYTE $0xd4 // movl $-44(%rbp), %ecx - WORD $0xc90f // bswapl %ecx - WORD $0xc889 // movl %ecx, %eax - WORD $0xd0f7 // notl %eax - WORD $0xe8c1; BYTE $0x04 // shrl $4, %eax - LONG $0x01010125; BYTE $0x01 // andl $16843009, %eax - WORD $0x048d; BYTE $0xc0 // leal (%rax,%rax,8), %eax - LONG $0x0f0fe181; WORD $0x0f0f // andl $252645135, %ecx - WORD $0xc101 // addl %eax, %ecx - WORD $0xc889 // movl %ecx, %eax - WORD $0xe8c1; BYTE $0x04 // shrl $4, %eax - WORD $0xc809 // orl %ecx, %eax - WORD $0xb60f; BYTE $0xc8 // movzbl %al, %ecx - WORD $0xe8c1; BYTE $0x08 // shrl $8, %eax - LONG $0x00ff0025; BYTE $0x00 // andl $65280, %eax - WORD $0x148d; BYTE $0x08 // leal (%rax,%rcx), %edx - LONG $0x2000c281; WORD $0xffff // addl $-57344, %edx - LONG $0xfbfffa81; WORD $0xffff // cmpl $-1025, %edx - LONG $0x0018870f; WORD $0x0000 // ja LBB41_28, $24(%rip) - LONG $0xc8458b48 // movq $-56(%rbp), %rax - WORD $0x8949; BYTE $0x07 // movq %rax, (%r15) - LONG $0xfffe98e9; BYTE $0xff // jmp LBB41_13, $-360(%rip) - -LBB41_27: - LONG $0xc8458b48 // movq $-56(%rbp), %rax - WORD $0x8949; BYTE $0x07 // movq %rax, (%r15) - LONG $0xfffe85e9; BYTE $0xff // jmp LBB41_12, $-379(%rip) - -LBB41_28: - WORD $0xc809 // orl %ecx, %eax - LONG $0x0ae4c141 // shll $10, %r12d - WORD $0xc189 // movl %eax, %ecx - WORD $0x0144; BYTE $0xe1 // addl %r12d, %ecx - WORD $0x0144; BYTE $0xe0 // addl %r12d, %eax - LONG $0xa0240005; BYTE $0xfc // addl $-56613888, %eax - WORD $0xc289 // movl %eax, %edx - WORD $0xeac1; BYTE $0x12 // shrl $18, %edx - WORD $0xc689 // movl %eax, %esi - WORD $0xeec1; BYTE $0x0c // shrl $12, %esi - LONG $0x3fe68040 // andb $63, %sil - WORD $0xe8c1; BYTE $0x06 // shrl $6, %eax - WORD $0x3f24 // andb $63, %al - WORD $0xe180; BYTE $0x3f // andb $63, %cl - LONG $0xc26ef9c5 // vmovd %edx, %xmm0 - LONG $0xd6b60f40 // movzbl %sil, %edx - LONG $0x2079e3c4; WORD $0x01c2 // vpinsrb $1, %edx, %xmm0, %xmm0 - WORD $0xb60f; BYTE $0xc0 // movzbl %al, %eax - LONG $0x2079e3c4; WORD $0x02c0 // vpinsrb $2, %eax, %xmm0, %xmm0 - WORD $0xb60f; BYTE $0xc1 // movzbl %cl, %eax - LONG $0x2079e3c4; WORD $0x03c0 // vpinsrb $3, %eax, %xmm0, %xmm0 - QUAD $0xfffffd3105ebf9c5 // vpor $-719(%rip), %xmm0, %xmm0 /* LCPI41_0(%rip) */ - LONG $0x7e79c1c4; BYTE $0x06 // vmovd %xmm0, (%r14) - LONG $0x0cc58349 // addq $12, %r13 - WORD $0x894d; BYTE $0x2f // movq %r13, (%r15) - LONG $0x000004bb; BYTE $0x00 // movl $4, %ebx - LONG $0xfffe25e9; BYTE $0xff // jmp LBB41_13, $-475(%rip) - QUAD $0x0000000000000000; WORD $0x0000; BYTE $0x00 // .p2align 4, 0x00 +LBB36_16: + LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax + LONG $0xfffec3e9; BYTE $0xff // jmp LBB36_15, $-317(%rip) + QUAD $0x0000000000000000; LONG $0x00000000; WORD $0x0000 // .p2align 4, 0x00 _POW10_M128_TAB: QUAD $0x1732c869cd60e453 // .quad 1671618768450675795 @@ -13433,7 +12775,7 @@ _Digits: QUAD $0x3939383937393639 // .ascii 8, '96979899' QUAD $0x0000000000000000 // .p2align 4, 0x00 -_LB_5d8b2db8: // _pow10_ceil_sig.g +_LB_35efc682: // _pow10_ceil_sig.g QUAD $0xff77b1fcbebcdc4f // .quad -38366372719436721 QUAD $0x25e8e89c13bb0f7b // .quad 2731688931043774331 QUAD $0x9faacf3df73609b1 // .quad -6941508010590729807 @@ -16088,7 +15430,7 @@ _P10_TAB: QUAD $0x4480f0cf064dd592 // .quad 0x4480f0cf064dd592 QUAD $0x0000000000000000 // .p2align 4, 0x00 -_LB_85cdfac5: // _pow10_ceil_sig_f32.g +_LB_2202da27: // _pow10_ceil_sig_f32.g QUAD $0x81ceb32c4b43fcf5 // .quad -9093133594791772939 QUAD $0xa2425ff75e14fc32 // .quad -6754730975062328270 QUAD $0xcad2f7f5359a3b3f // .quad -3831727700400522433 @@ -16172,14 +15514,14 @@ TEXT ·__f32toa(SB), NOSPLIT | NOFRAME, $0 - 24 _entry: MOVQ (TLS), R14 - LEAQ -56(SP), R12 + LEAQ -48(SP), R12 CMPQ R12, 16(R14) JBE _stack_grow _f32toa: MOVQ out+0(FP), DI MOVSD val+8(FP), X0 - CALL ·__native_entry__+35216(SB) // _f32toa + CALL ·__native_entry__+33888(SB) // _f32toa MOVQ AX, ret+16(FP) RET @@ -16199,7 +15541,7 @@ _entry: _f64toa: MOVQ out+0(FP), DI MOVSD val+8(FP), X0 - CALL ·__native_entry__+752(SB) // _f64toa + CALL ·__native_entry__+288(SB) // _f64toa MOVQ AX, ret+16(FP) RET @@ -16207,12 +15549,12 @@ _stack_grow: CALL runtime·morestack_noctxt<>(SB) JMP _entry -TEXT ·__get_by_path(SB), NOSPLIT | NOFRAME, $0 - 32 +TEXT ·__get_by_path(SB), NOSPLIT | NOFRAME, $0 - 40 NO_LOCAL_POINTERS _entry: MOVQ (TLS), R14 - LEAQ -320(SP), R12 + LEAQ -296(SP), R12 CMPQ R12, 16(R14) JBE _stack_grow @@ -16220,8 +15562,9 @@ _get_by_path: MOVQ s+0(FP), DI MOVQ p+8(FP), SI MOVQ path+16(FP), DX - CALL ·__native_entry__+30384(SB) // _get_by_path - MOVQ AX, ret+24(FP) + MOVQ m+24(FP), CX + CALL ·__native_entry__+28336(SB) // _get_by_path + MOVQ AX, ret+32(FP) RET _stack_grow: @@ -16242,7 +15585,7 @@ _html_escape: MOVQ nb+8(FP), SI MOVQ dp+16(FP), DX MOVQ dn+24(FP), CX - CALL ·__native_entry__+11712(SB) // _html_escape + CALL ·__native_entry__+10496(SB) // _html_escape MOVQ AX, ret+32(FP) RET @@ -16262,7 +15605,7 @@ _entry: _i64toa: MOVQ out+0(FP), DI MOVQ val+8(FP), SI - CALL ·__native_entry__+4368(SB) // _i64toa + CALL ·__native_entry__+3584(SB) // _i64toa MOVQ AX, ret+16(FP) RET @@ -16283,7 +15626,7 @@ _lspace: MOVQ sp+0(FP), DI MOVQ nb+8(FP), SI MOVQ off+16(FP), DX - CALL ·__native_entry__+224(SB) // _lspace + CALL ·__native_entry__+64(SB) // _lspace MOVQ AX, ret+24(FP) RET @@ -16296,7 +15639,7 @@ TEXT ·__quote(SB), NOSPLIT | NOFRAME, $0 - 48 _entry: MOVQ (TLS), R14 - LEAQ -72(SP), R12 + LEAQ -56(SP), R12 CMPQ R12, 16(R14) JBE _stack_grow @@ -16306,7 +15649,7 @@ _quote: MOVQ dp+16(FP), DX MOVQ dn+24(FP), CX MOVQ flags+32(FP), R8 - CALL ·__native_entry__+6160(SB) // _quote + CALL ·__native_entry__+5072(SB) // _quote MOVQ AX, ret+40(FP) RET @@ -16319,7 +15662,7 @@ TEXT ·__skip_array(SB), NOSPLIT | NOFRAME, $0 - 40 _entry: MOVQ (TLS), R14 - LEAQ -120(SP), R12 + LEAQ -128(SP), R12 CMPQ R12, 16(R14) JBE _stack_grow @@ -16328,7 +15671,7 @@ _skip_array: MOVQ p+8(FP), SI MOVQ m+16(FP), DX MOVQ flags+24(FP), CX - CALL ·__native_entry__+22864(SB) // _skip_array + CALL ·__native_entry__+20688(SB) // _skip_array MOVQ AX, ret+32(FP) RET @@ -16341,14 +15684,14 @@ TEXT ·__skip_number(SB), NOSPLIT | NOFRAME, $0 - 24 _entry: MOVQ (TLS), R14 - LEAQ -80(SP), R12 + LEAQ -72(SP), R12 CMPQ R12, 16(R14) JBE _stack_grow _skip_number: MOVQ s+0(FP), DI MOVQ p+8(FP), SI - CALL ·__native_entry__+26928(SB) // _skip_number + CALL ·__native_entry__+24912(SB) // _skip_number MOVQ AX, ret+16(FP) RET @@ -16361,7 +15704,7 @@ TEXT ·__skip_object(SB), NOSPLIT | NOFRAME, $0 - 40 _entry: MOVQ (TLS), R14 - LEAQ -120(SP), R12 + LEAQ -128(SP), R12 CMPQ R12, 16(R14) JBE _stack_grow @@ -16370,7 +15713,7 @@ _skip_object: MOVQ p+8(FP), SI MOVQ m+16(FP), DX MOVQ flags+24(FP), CX - CALL ·__native_entry__+24864(SB) // _skip_object + CALL ·__native_entry__+22736(SB) // _skip_object MOVQ AX, ret+32(FP) RET @@ -16383,7 +15726,7 @@ TEXT ·__skip_one(SB), NOSPLIT | NOFRAME, $0 - 40 _entry: MOVQ (TLS), R14 - LEAQ -120(SP), R12 + LEAQ -128(SP), R12 CMPQ R12, 16(R14) JBE _stack_grow @@ -16392,7 +15735,7 @@ _skip_one: MOVQ p+8(FP), SI MOVQ m+16(FP), DX MOVQ flags+24(FP), CX - CALL ·__native_entry__+27088(SB) // _skip_one + CALL ·__native_entry__+25072(SB) // _skip_one MOVQ AX, ret+32(FP) RET @@ -16405,14 +15748,14 @@ TEXT ·__skip_one_fast(SB), NOSPLIT | NOFRAME, $0 - 24 _entry: MOVQ (TLS), R14 - LEAQ -216(SP), R12 + LEAQ -208(SP), R12 CMPQ R12, 16(R14) JBE _stack_grow _skip_one_fast: MOVQ s+0(FP), DI MOVQ p+8(FP), SI - CALL ·__native_entry__+27504(SB) // _skip_one_fast + CALL ·__native_entry__+25488(SB) // _skip_one_fast MOVQ AX, ret+16(FP) RET @@ -16432,7 +15775,7 @@ _entry: _u64toa: MOVQ out+0(FP), DI MOVQ val+8(FP), SI - CALL ·__native_entry__+4640(SB) // _u64toa + CALL ·__native_entry__+3696(SB) // _u64toa MOVQ AX, ret+16(FP) RET @@ -16445,7 +15788,7 @@ TEXT ·__unquote(SB), NOSPLIT | NOFRAME, $0 - 48 _entry: MOVQ (TLS), R14 - LEAQ -128(SP), R12 + LEAQ -72(SP), R12 CMPQ R12, 16(R14) JBE _stack_grow @@ -16455,7 +15798,7 @@ _unquote: MOVQ dp+16(FP), DX MOVQ ep+24(FP), CX MOVQ flags+32(FP), R8 - CALL ·__native_entry__+8960(SB) // _unquote + CALL ·__native_entry__+7888(SB) // _unquote MOVQ AX, ret+40(FP) RET @@ -16468,7 +15811,7 @@ TEXT ·__validate_one(SB), NOSPLIT | NOFRAME, $0 - 32 _entry: MOVQ (TLS), R14 - LEAQ -120(SP), R12 + LEAQ -128(SP), R12 CMPQ R12, 16(R14) JBE _stack_grow @@ -16476,7 +15819,7 @@ _validate_one: MOVQ s+0(FP), DI MOVQ p+8(FP), SI MOVQ m+16(FP), DX - CALL ·__native_entry__+27152(SB) // _validate_one + CALL ·__native_entry__+25136(SB) // _validate_one MOVQ AX, ret+24(FP) RET @@ -16497,7 +15840,7 @@ _validate_utf8: MOVQ s+0(FP), DI MOVQ p+8(FP), SI MOVQ m+16(FP), DX - CALL ·__native_entry__+31552(SB) // _validate_utf8 + CALL ·__native_entry__+30320(SB) // _validate_utf8 MOVQ AX, ret+24(FP) RET @@ -16510,13 +15853,13 @@ TEXT ·__validate_utf8_fast(SB), NOSPLIT | NOFRAME, $0 - 16 _entry: MOVQ (TLS), R14 - LEAQ -200(SP), R12 + LEAQ -176(SP), R12 CMPQ R12, 16(R14) JBE _stack_grow _validate_utf8_fast: MOVQ s+0(FP), DI - CALL ·__native_entry__+32496(SB) // _validate_utf8_fast + CALL ·__native_entry__+31280(SB) // _validate_utf8_fast MOVQ AX, ret+8(FP) RET @@ -16529,7 +15872,7 @@ TEXT ·__value(SB), NOSPLIT | NOFRAME, $0 - 48 _entry: MOVQ (TLS), R14 - LEAQ -368(SP), R12 + LEAQ -328(SP), R12 CMPQ R12, 16(R14) JBE _stack_grow @@ -16539,7 +15882,7 @@ _value: MOVQ p+16(FP), DX MOVQ v+24(FP), CX MOVQ flags+32(FP), R8 - CALL ·__native_entry__+16816(SB) // _value + CALL ·__native_entry__+15024(SB) // _value MOVQ AX, ret+40(FP) RET @@ -16552,7 +15895,7 @@ TEXT ·__vnumber(SB), NOSPLIT | NOFRAME, $0 - 24 _entry: MOVQ (TLS), R14 - LEAQ -280(SP), R12 + LEAQ -240(SP), R12 CMPQ R12, 16(R14) JBE _stack_grow @@ -16560,7 +15903,7 @@ _vnumber: MOVQ s+0(FP), DI MOVQ p+8(FP), SI MOVQ v+16(FP), DX - LEAQ ·__native_entry__+20608(SB), AX // _vnumber + LEAQ ·__native_entry__+18352(SB), AX // _vnumber JMP AX _stack_grow: @@ -16580,7 +15923,7 @@ _vsigned: MOVQ s+0(FP), DI MOVQ p+8(FP), SI MOVQ v+16(FP), DX - LEAQ ·__native_entry__+22144(SB), AX // _vsigned + LEAQ ·__native_entry__+19968(SB), AX // _vsigned JMP AX _stack_grow: @@ -16592,7 +15935,7 @@ TEXT ·__vstring(SB), NOSPLIT | NOFRAME, $0 - 32 _entry: MOVQ (TLS), R14 - LEAQ -104(SP), R12 + LEAQ -112(SP), R12 CMPQ R12, 16(R14) JBE _stack_grow @@ -16601,7 +15944,7 @@ _vstring: MOVQ p+8(FP), SI MOVQ v+16(FP), DX MOVQ flags+24(FP), CX - LEAQ ·__native_entry__+19312(SB), AX // _vstring + LEAQ ·__native_entry__+17024(SB), AX // _vstring JMP AX _stack_grow: @@ -16613,7 +15956,7 @@ TEXT ·__vunsigned(SB), NOSPLIT | NOFRAME, $0 - 24 _entry: MOVQ (TLS), R14 - LEAQ -24(SP), R12 + LEAQ -16(SP), R12 CMPQ R12, 16(R14) JBE _stack_grow @@ -16621,7 +15964,7 @@ _vunsigned: MOVQ s+0(FP), DI MOVQ p+8(FP), SI MOVQ v+16(FP), DX - LEAQ ·__native_entry__+22496(SB), AX // _vunsigned + LEAQ ·__native_entry__+20336(SB), AX // _vunsigned JMP AX _stack_grow: diff --git a/vendor/github.com/bytedance/sonic/internal/native/avx2/native_subr_amd64.go b/vendor/github.com/bytedance/sonic/internal/native/avx2/native_subr_amd64.go index bd8014e58..10b3d60f5 100644 --- a/vendor/github.com/bytedance/sonic/internal/native/avx2/native_subr_amd64.go +++ b/vendor/github.com/bytedance/sonic/internal/native/avx2/native_subr_amd64.go @@ -9,53 +9,53 @@ package avx2 func __native_entry__() uintptr var ( - _subr__f32toa = __native_entry__() + 35216 - _subr__f64toa = __native_entry__() + 752 - _subr__get_by_path = __native_entry__() + 30384 - _subr__html_escape = __native_entry__() + 11712 - _subr__i64toa = __native_entry__() + 4368 - _subr__lspace = __native_entry__() + 224 - _subr__quote = __native_entry__() + 6160 - _subr__skip_array = __native_entry__() + 22864 - _subr__skip_number = __native_entry__() + 26928 - _subr__skip_object = __native_entry__() + 24864 - _subr__skip_one = __native_entry__() + 27088 - _subr__skip_one_fast = __native_entry__() + 27504 - _subr__u64toa = __native_entry__() + 4640 - _subr__unquote = __native_entry__() + 8960 - _subr__validate_one = __native_entry__() + 27152 - _subr__validate_utf8 = __native_entry__() + 31552 - _subr__validate_utf8_fast = __native_entry__() + 32496 - _subr__value = __native_entry__() + 16816 - _subr__vnumber = __native_entry__() + 20608 - _subr__vsigned = __native_entry__() + 22144 - _subr__vstring = __native_entry__() + 19312 - _subr__vunsigned = __native_entry__() + 22496 + _subr__f32toa = __native_entry__() + 33888 + _subr__f64toa = __native_entry__() + 288 + _subr__get_by_path = __native_entry__() + 28336 + _subr__html_escape = __native_entry__() + 10496 + _subr__i64toa = __native_entry__() + 3584 + _subr__lspace = __native_entry__() + 64 + _subr__quote = __native_entry__() + 5072 + _subr__skip_array = __native_entry__() + 20688 + _subr__skip_number = __native_entry__() + 24912 + _subr__skip_object = __native_entry__() + 22736 + _subr__skip_one = __native_entry__() + 25072 + _subr__skip_one_fast = __native_entry__() + 25488 + _subr__u64toa = __native_entry__() + 3696 + _subr__unquote = __native_entry__() + 7888 + _subr__validate_one = __native_entry__() + 25136 + _subr__validate_utf8 = __native_entry__() + 30320 + _subr__validate_utf8_fast = __native_entry__() + 31280 + _subr__value = __native_entry__() + 15024 + _subr__vnumber = __native_entry__() + 18352 + _subr__vsigned = __native_entry__() + 19968 + _subr__vstring = __native_entry__() + 17024 + _subr__vunsigned = __native_entry__() + 20336 ) const ( - _stack__f32toa = 56 + _stack__f32toa = 48 _stack__f64toa = 80 - _stack__get_by_path = 320 + _stack__get_by_path = 296 _stack__html_escape = 72 _stack__i64toa = 16 _stack__lspace = 8 - _stack__quote = 72 - _stack__skip_array = 120 - _stack__skip_number = 80 - _stack__skip_object = 120 - _stack__skip_one = 120 - _stack__skip_one_fast = 216 + _stack__quote = 56 + _stack__skip_array = 128 + _stack__skip_number = 72 + _stack__skip_object = 128 + _stack__skip_one = 128 + _stack__skip_one_fast = 208 _stack__u64toa = 8 - _stack__unquote = 128 - _stack__validate_one = 120 + _stack__unquote = 72 + _stack__validate_one = 128 _stack__validate_utf8 = 48 - _stack__validate_utf8_fast = 200 - _stack__value = 368 - _stack__vnumber = 280 + _stack__validate_utf8_fast = 176 + _stack__value = 328 + _stack__vnumber = 240 _stack__vsigned = 16 - _stack__vstring = 104 - _stack__vunsigned = 24 + _stack__vstring = 112 + _stack__vunsigned = 16 ) var ( diff --git a/vendor/github.com/bytedance/sonic/internal/native/dispatch_amd64.go b/vendor/github.com/bytedance/sonic/internal/native/dispatch_amd64.go index 6aba0051f..11e517231 100644 --- a/vendor/github.com/bytedance/sonic/internal/native/dispatch_amd64.go +++ b/vendor/github.com/bytedance/sonic/internal/native/dispatch_amd64.go @@ -94,7 +94,7 @@ func SkipOneFast(s *string, p *int) int //go:nosplit //go:noescape //goland:noinspection GoUnusedParameter -func GetByPath(s *string, p *int, path *[]interface{}) int +func GetByPath(s *string, p *int, path *[]interface{}, m *types.StateMachine) int //go:nosplit //go:noescape diff --git a/vendor/github.com/bytedance/sonic/internal/native/dispatch_amd64.s b/vendor/github.com/bytedance/sonic/internal/native/dispatch_amd64.s index 858fe0212..bfd2f52db 100644 --- a/vendor/github.com/bytedance/sonic/internal/native/dispatch_amd64.s +++ b/vendor/github.com/bytedance/sonic/internal/native/dispatch_amd64.s @@ -72,7 +72,7 @@ TEXT ·SkipOneFast(SB), NOSPLIT, $0 - 24 JMP github·com∕bytedance∕sonic∕internal∕native∕avx·__skip_one_fast(SB) JMP github·com∕bytedance∕sonic∕internal∕native∕sse·__skip_one_fast(SB) -TEXT ·GetByPath(SB), NOSPLIT, $0 - 32 +TEXT ·GetByPath(SB), NOSPLIT, $0 - 40 CMPB github·com∕bytedance∕sonic∕internal∕cpu·HasAVX2(SB), $0 JE 2(PC) JMP github·com∕bytedance∕sonic∕internal∕native∕avx2·__get_by_path(SB) diff --git a/vendor/github.com/bytedance/sonic/internal/native/native_amd64.tmpl b/vendor/github.com/bytedance/sonic/internal/native/native_amd64.tmpl index 357a9f480..40cbf1613 100644 --- a/vendor/github.com/bytedance/sonic/internal/native/native_amd64.tmpl +++ b/vendor/github.com/bytedance/sonic/internal/native/native_amd64.tmpl @@ -120,7 +120,7 @@ func __validate_one(s *string, p *int, m *types.StateMachine) (ret int) //go:nosplit //go:noescape //goland:noinspection GoUnusedParameter -func __get_by_path(s *string, p *int, path *[]interface{}) (ret int) +func __get_by_path(s *string, p *int, path *[]interface{}, m *types.StateMachine) (ret int) //go:nosplit //go:noescape diff --git a/vendor/github.com/bytedance/sonic/internal/native/sse/native_amd64.go b/vendor/github.com/bytedance/sonic/internal/native/sse/native_amd64.go index 4cd4b0c7f..cb30a0ebf 100644 --- a/vendor/github.com/bytedance/sonic/internal/native/sse/native_amd64.go +++ b/vendor/github.com/bytedance/sonic/internal/native/sse/native_amd64.go @@ -122,7 +122,7 @@ func __validate_one(s *string, p *int, m *types.StateMachine) (ret int) //go:nosplit //go:noescape //goland:noinspection GoUnusedParameter -func __get_by_path(s *string, p *int, path *[]interface{}) (ret int) +func __get_by_path(s *string, p *int, path *[]interface{}, m *types.StateMachine) (ret int) //go:nosplit //go:noescape diff --git a/vendor/github.com/bytedance/sonic/internal/native/sse/native_amd64.s b/vendor/github.com/bytedance/sonic/internal/native/sse/native_amd64.s index 08a68f957..a2e12326f 100644 --- a/vendor/github.com/bytedance/sonic/internal/native/sse/native_amd64.s +++ b/vendor/github.com/bytedance/sonic/internal/native/sse/native_amd64.s @@ -10,130 +10,47 @@ TEXT ·__native_entry__(SB), NOSPLIT, $0 LONG $0xf9058d48; WORD $0xffff; BYTE $0xff // leaq $-7(%rip), %rax LONG $0x24448948; BYTE $0x08 // movq %rax, $8(%rsp) BYTE $0xc3 // retq - WORD $0x0000; BYTE $0x00 // .p2align 4, 0x00 - -LCPI0_0: - QUAD $0x2020202020202020; QUAD $0x2020202020202020 // .space 16, ' ' - -LCPI0_1: - QUAD $0x0909090909090909; QUAD $0x0909090909090909 // .space 16, '\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t' - -LCPI0_2: - QUAD $0x0a0a0a0a0a0a0a0a; QUAD $0x0a0a0a0a0a0a0a0a // .space 16, '\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n' - -LCPI0_3: - QUAD $0x0d0d0d0d0d0d0d0d; QUAD $0x0d0d0d0d0d0d0d0d // .space 16, '\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r' + WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 - // .p2align 4, 0x90 _lspace: - BYTE $0x55 // pushq %rbp - WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp - WORD $0x8948; BYTE $0xd0 // movq %rdx, %rax - LONG $0x17148d4c // leaq (%rdi,%rdx), %r10 - WORD $0x8948; BYTE $0xf2 // movq %rsi, %rdx - WORD $0x2948; BYTE $0xc2 // subq %rax, %rdx - LONG $0x0066840f; WORD $0x0000 // je LBB0_7, $102(%rip) - WORD $0x8944; BYTE $0xd1 // movl %r10d, %ecx - WORD $0xe183; BYTE $0x0f // andl $15, %ecx - LONG $0x005a840f; WORD $0x0000 // je LBB0_7, $90(%rip) - LONG $0x014f8d4c // leaq $1(%rdi), %r9 - LONG $0xff4e8d48 // leaq $-1(%rsi), %rcx - QUAD $0x000100002600b849; WORD $0x0000 // movabsq $4294977024, %r8 - QUAD $0x9090909090909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x3948; BYTE $0xd6 // cmpq %rdx, %rsi + LONG $0x004e840f; WORD $0x0000 // je LBB0_1, $78(%rip) + LONG $0x37048d4c // leaq (%rdi,%rsi), %r8 + LONG $0x3a448d48; BYTE $0x01 // leaq $1(%rdx,%rdi), %rax + WORD $0x2948; BYTE $0xf2 // subq %rsi, %rdx + QUAD $0x000100002600be48; WORD $0x0000 // movabsq $4294977024, %rsi + QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 LBB0_3: - LONG $0x0714be0f // movsbl (%rdi,%rax), %edx - WORD $0xfa83; BYTE $0x20 // cmpl $32, %edx - LONG $0x0100870f; WORD $0x0000 // ja LBB0_22, $256(%rip) - LONG $0xd0a30f49 // btq %rdx, %r8 - LONG $0x00f6830f; WORD $0x0000 // jae LBB0_22, $246(%rip) - LONG $0x01508d48 // leaq $1(%rax), %rdx - WORD $0x3948; BYTE $0xc1 // cmpq %rax, %rcx - LONG $0x000f840f; WORD $0x0000 // je LBB0_6, $15(%rip) - WORD $0x0144; BYTE $0xc8 // addl %r9d, %eax - WORD $0xe083; BYTE $0x0f // andl $15, %eax - WORD $0x8948; BYTE $0xd0 // movq %rdx, %rax - LONG $0xffcd850f; WORD $0xffff // jne LBB0_3, $-51(%rip) - -LBB0_6: - LONG $0x17148d4c // leaq (%rdi,%rdx), %r10 - WORD $0x2948; BYTE $0xd6 // subq %rdx, %rsi - WORD $0x8948; BYTE $0xf2 // movq %rsi, %rdx - -LBB0_7: - LONG $0x10fa8348 // cmpq $16, %rdx - LONG $0x007a820f; WORD $0x0000 // jb LBB0_13, $122(%rip) - WORD $0x8948; BYTE $0xfe // movq %rdi, %rsi - WORD $0x294c; BYTE $0xd6 // subq %r10, %rsi - QUAD $0xffffff2b056f0f66 // movdqa $-213(%rip), %xmm0 /* LCPI0_0(%rip) */ - QUAD $0xffffff330d6f0f66 // movdqa $-205(%rip), %xmm1 /* LCPI0_1(%rip) */ - QUAD $0xffffff3b156f0f66 // movdqa $-197(%rip), %xmm2 /* LCPI0_2(%rip) */ - QUAD $0xffffff431d6f0f66 // movdqa $-189(%rip), %xmm3 /* LCPI0_3(%rip) */ - WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 - -LBB0_9: - LONG $0x6f0f4166; BYTE $0x22 // movdqa (%r10), %xmm4 - LONG $0xec6f0f66 // movdqa %xmm4, %xmm5 - LONG $0xe8740f66 // pcmpeqb %xmm0, %xmm5 - LONG $0xf46f0f66 // movdqa %xmm4, %xmm6 - LONG $0xf1740f66 // pcmpeqb %xmm1, %xmm6 - LONG $0xf5eb0f66 // por %xmm5, %xmm6 - LONG $0xec6f0f66 // movdqa %xmm4, %xmm5 - LONG $0xea740f66 // pcmpeqb %xmm2, %xmm5 - LONG $0xe3740f66 // pcmpeqb %xmm3, %xmm4 - LONG $0xe5eb0f66 // por %xmm5, %xmm4 - LONG $0xe6eb0f66 // por %xmm6, %xmm4 - LONG $0xc4d70f66 // pmovmskb %xmm4, %eax - LONG $0xfff88366 // cmpw $-1, %ax - LONG $0x0064850f; WORD $0x0000 // jne LBB0_10, $100(%rip) - LONG $0x10c28349 // addq $16, %r10 - LONG $0xf0c28348 // addq $-16, %rdx - LONG $0xf0c68348 // addq $-16, %rsi - LONG $0x0ffa8348 // cmpq $15, %rdx - LONG $0xffaf870f; WORD $0xffff // ja LBB0_9, $-81(%rip) - -LBB0_13: - WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx - LONG $0x003d840f; WORD $0x0000 // je LBB0_20, $61(%rip) - LONG $0x12048d4d // leaq (%r10,%rdx), %r8 - WORD $0xc031 // xorl %eax, %eax - QUAD $0x000100002600b949; WORD $0x0000 // movabsq $4294977024, %r9 - LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 - -LBB0_15: - LONG $0x34be0f41; BYTE $0x02 // movsbl (%r10,%rax), %esi - WORD $0xfe83; BYTE $0x20 // cmpl $32, %esi - LONG $0x002e870f; WORD $0x0000 // ja LBB0_17, $46(%rip) - LONG $0xf1a30f49 // btq %rsi, %r9 - LONG $0x0024830f; WORD $0x0000 // jae LBB0_17, $36(%rip) + LONG $0xff48be0f // movsbl $-1(%rax), %ecx + WORD $0xf983; BYTE $0x20 // cmpl $32, %ecx + LONG $0x002c870f; WORD $0x0000 // ja LBB0_5, $44(%rip) + LONG $0xcea30f48 // btq %rcx, %rsi + LONG $0x0022830f; WORD $0x0000 // jae LBB0_5, $34(%rip) WORD $0xff48; BYTE $0xc0 // incq %rax - WORD $0x3948; BYTE $0xc2 // cmpq %rax, %rdx - LONG $0xffdc850f; WORD $0xffff // jne LBB0_15, $-36(%rip) - WORD $0x894d; BYTE $0xc2 // movq %r8, %r10 - -LBB0_20: - WORD $0x2949; BYTE $0xfa // subq %rdi, %r10 - -LBB0_21: - WORD $0x894c; BYTE $0xd0 // movq %r10, %rax - -LBB0_22: - BYTE $0x5d // popq %rbp - BYTE $0xc3 // retq + WORD $0xff48; BYTE $0xc2 // incq %rdx + LONG $0xffdd850f; WORD $0xffff // jne LBB0_3, $-35(%rip) + WORD $0x2949; BYTE $0xf8 // subq %rdi, %r8 + WORD $0x894c; BYTE $0xc0 // movq %r8, %rax + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq -LBB0_10: - WORD $0xb70f; BYTE $0xc0 // movzwl %ax, %eax - WORD $0xd0f7 // notl %eax - WORD $0xbc0f; BYTE $0xc0 // bsfl %eax, %eax - WORD $0x2948; BYTE $0xf0 // subq %rsi, %rax +LBB0_1: + WORD $0x0148; BYTE $0xfa // addq %rdi, %rdx + WORD $0x8949; BYTE $0xd0 // movq %rdx, %r8 + WORD $0x2949; BYTE $0xf8 // subq %rdi, %r8 + WORD $0x894c; BYTE $0xc0 // movq %r8, %rax BYTE $0x5d // popq %rbp BYTE $0xc3 // retq -LBB0_17: - WORD $0x2949; BYTE $0xfa // subq %rdi, %r10 - WORD $0x0149; BYTE $0xc2 // addq %rax, %r10 - LONG $0xffffe3e9; BYTE $0xff // jmp LBB0_21, $-29(%rip) - QUAD $0x0000000000000000; BYTE $0x00 // .p2align 4, 0x00 +LBB0_5: + WORD $0xf748; BYTE $0xd7 // notq %rdi + WORD $0x0148; BYTE $0xf8 // addq %rdi, %rax + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + QUAD $0x0000000000000000; LONG $0x00000000; WORD $0x0000; BYTE $0x00 // .p2align 4, 0x00 LCPI1_0: QUAD $0x3030303030303030; QUAD $0x3030303030303030 // .space 16, '0000000000000000' @@ -153,271 +70,264 @@ _f64toa: LONG $0x34e8c148 // shrq $52, %rax LONG $0x0007ff25; BYTE $0x00 // andl $2047, %eax LONG $0x0007ff3d; BYTE $0x00 // cmpl $2047, %eax - LONG $0x0acb840f; WORD $0x0000 // je LBB1_1, $2763(%rip) - WORD $0x8948; BYTE $0xfe // movq %rdi, %rsi + LONG $0x0abb840f; WORD $0x0000 // je LBB1_1, $2747(%rip) + WORD $0x8949; BYTE $0xfe // movq %rdi, %r14 WORD $0x07c6; BYTE $0x2d // movb $45, (%rdi) - WORD $0x8949; BYTE $0xd5 // movq %rdx, %r13 - LONG $0x3fedc149 // shrq $63, %r13 - LONG $0x2f3c8d4e // leaq (%rdi,%r13), %r15 + WORD $0x8949; BYTE $0xd4 // movq %rdx, %r12 + LONG $0x3fecc149 // shrq $63, %r12 + LONG $0x273c8d4e // leaq (%rdi,%r12), %r15 QUAD $0x00000000550c8d48 // leaq (,%rdx,2), %rcx WORD $0x8548; BYTE $0xc9 // testq %rcx, %rcx - LONG $0x01f5840f; WORD $0x0000 // je LBB1_3, $501(%rip) + LONG $0x01e3840f; WORD $0x0000 // je LBB1_3, $483(%rip) QUAD $0xffffffffffffbf48; WORD $0x000f // movabsq $4503599627370495, %rdi WORD $0x2148; BYTE $0xfa // andq %rdi, %rdx WORD $0xc085 // testl %eax, %eax - LONG $0xd0758948 // movq %rsi, $-48(%rbp) - LONG $0x0a97840f; WORD $0x0000 // je LBB1_5, $2711(%rip) + LONG $0x0a8b840f; WORD $0x0000 // je LBB1_5, $2699(%rip) WORD $0xff48; BYTE $0xc7 // incq %rdi WORD $0x0948; BYTE $0xd7 // orq %rdx, %rdi - LONG $0xfbcdb08d; WORD $0xffff // leal $-1075(%rax), %esi + LONG $0xfbcd988d; WORD $0xffff // leal $-1075(%rax), %ebx LONG $0xfc01888d; WORD $0xffff // leal $-1023(%rax), %ecx WORD $0xf983; BYTE $0x34 // cmpl $52, %ecx - LONG $0x001d870f; WORD $0x0000 // ja LBB1_6, $29(%rip) - LONG $0x000433b9; BYTE $0x00 // movl $1075, %ecx - WORD $0xc129 // subl %eax, %ecx - LONG $0xffc3c748; WORD $0xffff; BYTE $0xff // movq $-1, %rbx - WORD $0xd348; BYTE $0xe3 // shlq %cl, %rbx - WORD $0xf748; BYTE $0xd3 // notq %rbx - WORD $0x8548; BYTE $0xdf // testq %rbx, %rdi - LONG $0x0421840f; WORD $0x0000 // je LBB1_11, $1057(%rip) + LONG $0x001a870f; WORD $0x0000 // ja LBB1_6, $26(%rip) + WORD $0xd989 // movl %ebx, %ecx + WORD $0xd9f7 // negl %ecx + LONG $0xffc6c748; WORD $0xffff; BYTE $0xff // movq $-1, %rsi + WORD $0xd348; BYTE $0xe6 // shlq %cl, %rsi + WORD $0xf748; BYTE $0xd6 // notq %rsi + WORD $0x8548; BYTE $0xf7 // testq %rsi, %rdi + LONG $0x041e840f; WORD $0x0000 // je LBB1_11, $1054(%rip) LBB1_6: WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx WORD $0x940f; BYTE $0xc1 // sete %cl - WORD $0xf883; BYTE $0x02 // cmpl $2, %eax - WORD $0x930f; BYTE $0xc0 // setae %al + WORD $0xf883; BYTE $0x01 // cmpl $1, %eax + WORD $0x970f; BYTE $0xc0 // seta %al WORD $0xc820 // andb %cl, %al - QUAD $0x00000000bd0c8d4c // leaq (,%rdi,4), %r9 WORD $0xb60f; BYTE $0xc0 // movzbl %al, %eax - LONG $0xb81c8d48 // leaq (%rax,%rdi,4), %rbx - LONG $0xfec38348 // addq $-2, %rbx - LONG $0x4413ce69; WORD $0x0013 // imull $1262611, %esi, %ecx - LONG $0x01918d44; WORD $0xf801; BYTE $0xff // leal $-524031(%rcx), %r10d + LONG $0x4413cb69; WORD $0x0013 // imull $1262611, %ebx, %ecx + WORD $0xd231 // xorl %edx, %edx WORD $0xc084 // testb %al, %al - LONG $0xd1440f44 // cmovel %ecx, %r10d - QUAD $0x00000002bd048d4c // leaq $2(,%rdi,4), %r8 - LONG $0x16fac141 // sarl $22, %r10d - LONG $0xb1ca6941; WORD $0xe56c; BYTE $0xff // imull $-1741647, %r10d, %ecx + LONG $0x0101b941; WORD $0xfff8 // movl $-524031, %r9d + LONG $0xca440f44 // cmovel %edx, %r9d + LONG $0xb8748d48; BYTE $0xfe // leaq $-2(%rax,%rdi,4), %rsi + WORD $0x0141; BYTE $0xc9 // addl %ecx, %r9d + LONG $0x16f9c141 // sarl $22, %r9d + LONG $0xb1c96941; WORD $0xe56c; BYTE $0xff // imull $-1741647, %r9d, %ecx WORD $0xe9c1; BYTE $0x13 // shrl $19, %ecx - WORD $0xf101 // addl %esi, %ecx + WORD $0xd901 // addl %ebx, %ecx LONG $0x000124b8; BYTE $0x00 // movl $292, %eax - WORD $0x2944; BYTE $0xd0 // subl %r10d, %eax + WORD $0x2944; BYTE $0xc8 // subl %r9d, %eax LONG $0x04e0c148 // shlq $4, %rax - LONG $0xd4158d48; WORD $0x00b2; BYTE $0x00 // leaq $45780(%rip), %rdx /* _pow10_ceil_sig.g(%rip) */ + LONG $0x1a158d48; WORD $0x00bd; BYTE $0x00 // leaq $48410(%rip), %rdx /* _pow10_ceil_sig.g(%rip) */ LONG $0x101c8b4c // movq (%rax,%rdx), %r11 - LONG $0x10748b4c; BYTE $0x08 // movq $8(%rax,%rdx), %r14 + LONG $0x106c8b4c; BYTE $0x08 // movq $8(%rax,%rdx), %r13 WORD $0xc1fe // incb %cl - WORD $0xd348; BYTE $0xe3 // shlq %cl, %rbx - WORD $0x8948; BYTE $0xd8 // movq %rbx, %rax - WORD $0xf749; BYTE $0xe6 // mulq %r14 - WORD $0x8948; BYTE $0xd6 // movq %rdx, %rsi - WORD $0x8948; BYTE $0xd8 // movq %rbx, %rax - WORD $0xf749; BYTE $0xe3 // mulq %r11 - WORD $0x0148; BYTE $0xf0 // addq %rsi, %rax - LONG $0x00d28348 // adcq $0, %rdx - WORD $0xf631 // xorl %esi, %esi - LONG $0xfffea948; WORD $0xffff // testq $-2, %rax - LONG $0xc6950f40 // setne %sil - WORD $0x0948; BYTE $0xd6 // orq %rdx, %rsi - WORD $0xd349; BYTE $0xe1 // shlq %cl, %r9 - WORD $0x894c; BYTE $0xc8 // movq %r9, %rax - WORD $0xf749; BYTE $0xe6 // mulq %r14 + WORD $0xd348; BYTE $0xe6 // shlq %cl, %rsi + WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax + WORD $0xf749; BYTE $0xe5 // mulq %r13 WORD $0x8948; BYTE $0xd3 // movq %rdx, %rbx - WORD $0x894c; BYTE $0xc8 // movq %r9, %rax + WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax WORD $0xf749; BYTE $0xe3 // mulq %r11 - WORD $0x8949; BYTE $0xd1 // movq %rdx, %r9 + QUAD $0x00000000bd348d48 // leaq (,%rdi,4), %rsi WORD $0x0148; BYTE $0xd8 // addq %rbx, %rax - LONG $0x00d18349 // adcq $0, %r9 + LONG $0x00d28348 // adcq $0, %rdx WORD $0xdb31 // xorl %ebx, %ebx - LONG $0xfffea948; WORD $0xffff // testq $-2, %rax - WORD $0x950f; BYTE $0xc3 // setne %bl - WORD $0x094c; BYTE $0xcb // orq %r9, %rbx - WORD $0xd349; BYTE $0xe0 // shlq %cl, %r8 - WORD $0x894c; BYTE $0xc0 // movq %r8, %rax - WORD $0xf749; BYTE $0xe6 // mulq %r14 + LONG $0x01f88348 // cmpq $1, %rax + WORD $0x970f; BYTE $0xc3 // seta %bl + WORD $0x0948; BYTE $0xd3 // orq %rdx, %rbx + WORD $0xd348; BYTE $0xe6 // shlq %cl, %rsi + WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax + WORD $0xf749; BYTE $0xe5 // mulq %r13 + WORD $0x8949; BYTE $0xd2 // movq %rdx, %r10 + WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax + WORD $0xf749; BYTE $0xe3 // mulq %r11 + WORD $0x8949; BYTE $0xd0 // movq %rdx, %r8 + QUAD $0x00000002bd348d48 // leaq $2(,%rdi,4), %rsi + WORD $0x014c; BYTE $0xd0 // addq %r10, %rax + LONG $0x00d08349 // adcq $0, %r8 + WORD $0x3145; BYTE $0xd2 // xorl %r10d, %r10d + LONG $0x01f88348 // cmpq $1, %rax + LONG $0xc2970f41 // seta %r10b + WORD $0x094d; BYTE $0xc2 // orq %r8, %r10 + WORD $0xd348; BYTE $0xe6 // shlq %cl, %rsi + WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax + WORD $0xf749; BYTE $0xe5 // mulq %r13 WORD $0x8948; BYTE $0xd1 // movq %rdx, %rcx - WORD $0x894c; BYTE $0xc0 // movq %r8, %rax + WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax WORD $0xf749; BYTE $0xe3 // mulq %r11 WORD $0x0148; BYTE $0xc8 // addq %rcx, %rax LONG $0x00d28348 // adcq $0, %rdx WORD $0xc931 // xorl %ecx, %ecx - LONG $0xfffea948; WORD $0xffff // testq $-2, %rax - WORD $0x950f; BYTE $0xc1 // setne %cl + LONG $0x01f88348 // cmpq $1, %rax + WORD $0x970f; BYTE $0xc1 // seta %cl WORD $0x0948; BYTE $0xd1 // orq %rdx, %rcx WORD $0xe783; BYTE $0x01 // andl $1, %edi - WORD $0x0148; BYTE $0xfe // addq %rdi, %rsi + WORD $0x0148; BYTE $0xfb // addq %rdi, %rbx WORD $0x2948; BYTE $0xf9 // subq %rdi, %rcx - LONG $0x28fb8348 // cmpq $40, %rbx - LONG $0x0043820f; WORD $0x0000 // jb LBB1_28, $67(%rip) + LONG $0x28fa8349 // cmpq $40, %r10 + LONG $0x003e820f; WORD $0x0000 // jb LBB1_29, $62(%rip) QUAD $0xcccccccccccdba48; WORD $0xcccc // movabsq $-3689348814741910323, %rdx - WORD $0x894c; BYTE $0xc8 // movq %r9, %rax + WORD $0x894c; BYTE $0xc0 // movq %r8, %rax WORD $0xf748; BYTE $0xe2 // mulq %rdx WORD $0x8948; BYTE $0xd7 // movq %rdx, %rdi LONG $0x05efc148 // shrq $5, %rdi QUAD $0x00000000fd048d48 // leaq (,%rdi,8), %rax LONG $0x80148d48 // leaq (%rax,%rax,4), %rdx - WORD $0x3948; BYTE $0xd6 // cmpq %rdx, %rsi - LONG $0xc0970f41 // seta %r8b - LONG $0x80148d48 // leaq (%rax,%rax,4), %rdx - LONG $0x28c28348 // addq $40, %rdx - WORD $0xc031 // xorl %eax, %eax - WORD $0x3948; BYTE $0xca // cmpq %rcx, %rdx + WORD $0x3948; BYTE $0xd3 // cmpq %rdx, %rbx + LONG $0xc6970f40 // seta %sil + LONG $0x80448d48; BYTE $0x28 // leaq $40(%rax,%rax,4), %rax + WORD $0x3948; BYTE $0xc8 // cmpq %rcx, %rax WORD $0x960f; BYTE $0xc2 // setbe %dl - WORD $0x3841; BYTE $0xd0 // cmpb %dl, %r8b - LONG $0x0134840f; WORD $0x0000 // je LBB1_8, $308(%rip) + WORD $0x3040; BYTE $0xf2 // xorb %sil, %dl + LONG $0x0130840f; WORD $0x0000 // je LBB1_8, $304(%rip) -LBB1_28: - WORD $0x894d; BYTE $0xc8 // movq %r9, %r8 - LONG $0x02e8c149 // shrq $2, %r8 - WORD $0x894c; BYTE $0xca // movq %r9, %rdx +LBB1_29: + WORD $0x894c; BYTE $0xc0 // movq %r8, %rax + LONG $0x02e8c148 // shrq $2, %rax + WORD $0x894c; BYTE $0xc2 // movq %r8, %rdx LONG $0xfce28348 // andq $-4, %rdx - WORD $0x3948; BYTE $0xd6 // cmpq %rdx, %rsi + WORD $0x3948; BYTE $0xd3 // cmpq %rdx, %rbx LONG $0xc7970f40 // seta %dil LONG $0x04728d48 // leaq $4(%rdx), %rsi WORD $0x3948; BYTE $0xce // cmpq %rcx, %rsi - WORD $0x960f; BYTE $0xc0 // setbe %al - WORD $0x3040; BYTE $0xf8 // xorb %dil, %al - LONG $0x0055840f; WORD $0x0000 // je LBB1_29, $85(%rip) + WORD $0x960f; BYTE $0xc3 // setbe %bl + WORD $0x3040; BYTE $0xfb // xorb %dil, %bl + LONG $0x0053840f; WORD $0x0000 // je LBB1_30, $83(%rip) LONG $0x02ca8348 // orq $2, %rdx LONG $0x000001bf; BYTE $0x00 // movl $1, %edi - WORD $0x3948; BYTE $0xd3 // cmpq %rdx, %rbx - LONG $0x000e870f; WORD $0x0000 // ja LBB1_32, $14(%rip) - WORD $0x940f; BYTE $0xc0 // sete %al - LONG $0x02e9c041 // shrb $2, %r9b - WORD $0x2041; BYTE $0xc1 // andb %al, %r9b - LONG $0xf9b60f41 // movzbl %r9b, %edi - -LBB1_32: - WORD $0x014c; BYTE $0xc7 // addq %r8, %rdi - QUAD $0x0001ffffffe0bc49; WORD $0x0000 // movabsq $8589934560, %r12 - QUAD $0x540be41f24848d49 // leaq $1410065439(%r12), %rax + WORD $0x3949; BYTE $0xd2 // cmpq %rdx, %r10 + LONG $0x000e870f; WORD $0x0000 // ja LBB1_33, $14(%rip) + WORD $0x940f; BYTE $0xc1 // sete %cl + LONG $0x02e8c041 // shrb $2, %r8b + WORD $0x2041; BYTE $0xc8 // andb %cl, %r8b + LONG $0xf8b60f41 // movzbl %r8b, %edi + +LBB1_33: + WORD $0x0148; BYTE $0xc7 // addq %rax, %rdi + QUAD $0x0001ffffffe0b848; WORD $0x0000 // movabsq $8589934560, %rax + LONG $0xe41f0548; WORD $0x540b // addq $1410065439, %rax WORD $0x3948; BYTE $0xc7 // cmpq %rax, %rdi - LONG $0x003c870f; WORD $0x0000 // ja LBB1_34, $60(%rip) - LONG $0x0000ece9; BYTE $0x00 // jmp LBB1_40, $236(%rip) + LONG $0x003a870f; WORD $0x0000 // ja LBB1_35, $58(%rip) + LONG $0x0000eae9; BYTE $0x00 // jmp LBB1_41, $234(%rip) LBB1_3: LONG $0x3007c641 // movb $48, (%r15) - WORD $0x2941; BYTE $0xf7 // subl %esi, %r15d + WORD $0x2945; BYTE $0xf7 // subl %r14d, %r15d WORD $0xff41; BYTE $0xc7 // incl %r15d WORD $0x8944; BYTE $0xfb // movl %r15d, %ebx - LONG $0x000891e9; BYTE $0x00 // jmp LBB1_123, $2193(%rip) + LONG $0x000882e9; BYTE $0x00 // jmp LBB1_116, $2178(%rip) -LBB1_29: +LBB1_30: WORD $0x3948; BYTE $0xf1 // cmpq %rsi, %rcx - LONG $0xffd88349 // sbbq $-1, %r8 - WORD $0x894c; BYTE $0xc7 // movq %r8, %rdi - QUAD $0x0001ffffffe0bc49; WORD $0x0000 // movabsq $8589934560, %r12 - QUAD $0x540be41f24848d49 // leaq $1410065439(%r12), %rax + LONG $0xffd88348 // sbbq $-1, %rax + WORD $0x8948; BYTE $0xc7 // movq %rax, %rdi + QUAD $0x0001ffffffe0b848; WORD $0x0000 // movabsq $8589934560, %rax + LONG $0xe41f0548; WORD $0x540b // addq $1410065439, %rax WORD $0x3948; BYTE $0xc7 // cmpq %rax, %rdi - LONG $0x00b5860f; WORD $0x0000 // jbe LBB1_40, $181(%rip) + LONG $0x00b5860f; WORD $0x0000 // jbe LBB1_41, $181(%rip) -LBB1_34: +LBB1_35: WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax LONG $0x0be8c148 // shrq $11, %rax LONG $0x00000bba; BYTE $0x00 // movl $11, %edx LONG $0x0edd3d48; WORD $0x02e9 // cmpq $48828125, %rax - LONG $0x0136820f; WORD $0x0000 // jb LBB1_49, $310(%rip) + LONG $0x0127820f; WORD $0x0000 // jb LBB1_51, $295(%rip) WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax LONG $0x0ce8c148 // shrq $12, %rax LONG $0x00000cba; BYTE $0x00 // movl $12, %edx LONG $0x4a513d48; WORD $0x0e8d // cmpq $244140625, %rax - LONG $0x011e820f; WORD $0x0000 // jb LBB1_49, $286(%rip) + LONG $0x010f820f; WORD $0x0000 // jb LBB1_51, $271(%rip) WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax LONG $0x0de8c148 // shrq $13, %rax LONG $0x00000dba; BYTE $0x00 // movl $13, %edx LONG $0x73953d48; WORD $0x48c2 // cmpq $1220703125, %rax - LONG $0x0106820f; WORD $0x0000 // jb LBB1_49, $262(%rip) + LONG $0x00f7820f; WORD $0x0000 // jb LBB1_51, $247(%rip) LONG $0x00000eba; BYTE $0x00 // movl $14, %edx QUAD $0x5af3107a4000b848; WORD $0x0000 // movabsq $100000000000000, %rax WORD $0x3948; BYTE $0xc7 // cmpq %rax, %rdi - LONG $0x00ee820f; WORD $0x0000 // jb LBB1_49, $238(%rip) + LONG $0x00df820f; WORD $0x0000 // jb LBB1_51, $223(%rip) LONG $0x00000fba; BYTE $0x00 // movl $15, %edx QUAD $0x8d7ea4c68000b848; WORD $0x0003 // movabsq $1000000000000000, %rax WORD $0x3948; BYTE $0xc7 // cmpq %rax, %rdi - LONG $0x00d6820f; WORD $0x0000 // jb LBB1_49, $214(%rip) + LONG $0x00c7820f; WORD $0x0000 // jb LBB1_51, $199(%rip) QUAD $0x86f26fc10000b848; WORD $0x0023 // movabsq $10000000000000000, %rax - WORD $0xd231 // xorl %edx, %edx WORD $0x3948; BYTE $0xc7 // cmpq %rax, %rdi - WORD $0x920f; BYTE $0xc2 // setb %dl - WORD $0xf283; BYTE $0x11 // xorl $17, %edx - LONG $0x0000bce9; BYTE $0x00 // jmp LBB1_49, $188(%rip) + LONG $0x000011ba; BYTE $0x00 // movl $17, %edx + +LBB1_50: + WORD $0xda83; BYTE $0x00 // sbbl $0, %edx + LONG $0x0000ade9; BYTE $0x00 // jmp LBB1_51, $173(%rip) LBB1_8: - WORD $0xd088 // movb %dl, %al - WORD $0x0148; BYTE $0xc7 // addq %rax, %rdi - WORD $0xff41; BYTE $0xc2 // incl %r10d - QUAD $0x0001ffffffe0bc49; WORD $0x0000 // movabsq $8589934560, %r12 - QUAD $0x540be41f24848d49 // leaq $1410065439(%r12), %rax + WORD $0x3948; BYTE $0xc1 // cmpq %rax, %rcx + LONG $0xffdf8348 // sbbq $-1, %rdi + WORD $0xff41; BYTE $0xc1 // incl %r9d + QUAD $0x0001ffffffe0b848; WORD $0x0000 // movabsq $8589934560, %rax + LONG $0xe41f0548; WORD $0x540b // addq $1410065439, %rax WORD $0x3948; BYTE $0xc7 // cmpq %rax, %rdi - LONG $0xff4b870f; WORD $0xffff // ja LBB1_34, $-181(%rip) + LONG $0xff4b870f; WORD $0xffff // ja LBB1_35, $-181(%rip) -LBB1_40: +LBB1_41: LONG $0x000001ba; BYTE $0x00 // movl $1, %edx LONG $0x0aff8348 // cmpq $10, %rdi - LONG $0x008a820f; WORD $0x0000 // jb LBB1_49, $138(%rip) + LONG $0x007b820f; WORD $0x0000 // jb LBB1_51, $123(%rip) LONG $0x000002ba; BYTE $0x00 // movl $2, %edx LONG $0x64ff8348 // cmpq $100, %rdi - LONG $0x007b820f; WORD $0x0000 // jb LBB1_49, $123(%rip) + LONG $0x006c820f; WORD $0x0000 // jb LBB1_51, $108(%rip) LONG $0x000003ba; BYTE $0x00 // movl $3, %edx LONG $0xe8ff8148; WORD $0x0003; BYTE $0x00 // cmpq $1000, %rdi - LONG $0x0069820f; WORD $0x0000 // jb LBB1_49, $105(%rip) + LONG $0x005a820f; WORD $0x0000 // jb LBB1_51, $90(%rip) LONG $0x000004ba; BYTE $0x00 // movl $4, %edx LONG $0x10ff8148; WORD $0x0027; BYTE $0x00 // cmpq $10000, %rdi - LONG $0x0057820f; WORD $0x0000 // jb LBB1_49, $87(%rip) + LONG $0x0048820f; WORD $0x0000 // jb LBB1_51, $72(%rip) LONG $0x000005ba; BYTE $0x00 // movl $5, %edx LONG $0xa0ff8148; WORD $0x0186; BYTE $0x00 // cmpq $100000, %rdi - LONG $0x0045820f; WORD $0x0000 // jb LBB1_49, $69(%rip) + LONG $0x0036820f; WORD $0x0000 // jb LBB1_51, $54(%rip) LONG $0x000006ba; BYTE $0x00 // movl $6, %edx LONG $0x40ff8148; WORD $0x0f42; BYTE $0x00 // cmpq $1000000, %rdi - LONG $0x0033820f; WORD $0x0000 // jb LBB1_49, $51(%rip) + LONG $0x0024820f; WORD $0x0000 // jb LBB1_51, $36(%rip) LONG $0x000007ba; BYTE $0x00 // movl $7, %edx LONG $0x80ff8148; WORD $0x9896; BYTE $0x00 // cmpq $10000000, %rdi - LONG $0x0021820f; WORD $0x0000 // jb LBB1_49, $33(%rip) + LONG $0x0012820f; WORD $0x0000 // jb LBB1_51, $18(%rip) LONG $0x000008ba; BYTE $0x00 // movl $8, %edx LONG $0x00ff8148; WORD $0xf5e1; BYTE $0x05 // cmpq $100000000, %rdi - LONG $0x000f820f; WORD $0x0000 // jb LBB1_49, $15(%rip) - LONG $0x00ff8148; WORD $0x9aca; BYTE $0x3b // cmpq $1000000000, %rdi - LONG $0x00000aba; BYTE $0x00 // movl $10, %edx - WORD $0xda83; BYTE $0x00 // sbbl $0, %edx - -LBB1_49: - LONG $0x12348d46 // leal (%rdx,%r10), %r14d - LONG $0x12048d42 // leal (%rdx,%r10), %eax - WORD $0xc083; BYTE $0xea // addl $-22, %eax - WORD $0xf883; BYTE $0xe4 // cmpl $-28, %eax - LONG $0x00a4870f; WORD $0x0000 // ja LBB1_62, $164(%rip) - LONG $0x01678d4d // leaq $1(%r15), %r12 - WORD $0x894c; BYTE $0xe6 // movq %r12, %rsi - LONG $0x00772ae8; BYTE $0x00 // callq _format_significand, $30506(%rip) - WORD $0x8948; BYTE $0xc3 // movq %rax, %rbx - LONG $0xd0558b4c // movq $-48(%rbp), %r10 - WORD $0x294c; BYTE $0xd0 // subq %r10, %rax - WORD $0x294c; BYTE $0xe8 // subq %r13, %rax - QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 + LONG $0x0731830f; WORD $0x0000 // jae LBB1_49, $1841(%rip) LBB1_51: - WORD $0xff48; BYTE $0xc8 // decq %rax + LONG $0x0a2c8d46 // leal (%rdx,%r9), %r13d + LONG $0x0a448d42; BYTE $0x05 // leal $5(%rdx,%r9), %eax + WORD $0xf883; BYTE $0x1b // cmpl $27, %eax + LONG $0x009d820f; WORD $0x0000 // jb LBB1_64, $157(%rip) + LONG $0x01678d4d // leaq $1(%r15), %r12 + WORD $0x894c; BYTE $0xe6 // movq %r12, %rsi + LONG $0x00848fe8; BYTE $0x00 // callq _format_significand, $33935(%rip) + WORD $0x8948; BYTE $0xc3 // movq %rax, %rbx + QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90 + +LBB1_53: LONG $0x30ff7b80 // cmpb $48, $-1(%rbx) LONG $0xff5b8d48 // leaq $-1(%rbx), %rbx - LONG $0xffef840f; WORD $0xffff // je LBB1_51, $-17(%rip) - LONG $0x4fb60f41; BYTE $0x01 // movzbl $1(%r15), %ecx - WORD $0x8841; BYTE $0x0f // movb %cl, (%r15) - LONG $0x02f88348 // cmpq $2, %rax - LONG $0x00088c0f; WORD $0x0000 // jl LBB1_54, $8(%rip) - WORD $0xff48; BYTE $0xc3 // incq %rbx + LONG $0xfff2840f; WORD $0xffff // je LBB1_53, $-14(%rip) + LONG $0x01478a41 // movb $1(%r15), %al + WORD $0x8841; BYTE $0x07 // movb %al, (%r15) + LONG $0x01438d48 // leaq $1(%rbx), %rax + WORD $0x8948; BYTE $0xc1 // movq %rax, %rcx + WORD $0x294c; BYTE $0xe1 // subq %r12, %rcx + LONG $0x02f98348 // cmpq $2, %rcx + LONG $0x00088c0f; WORD $0x0000 // jl LBB1_56, $8(%rip) LONG $0x2404c641; BYTE $0x2e // movb $46, (%r12) + WORD $0x8948; BYTE $0xc3 // movq %rax, %rbx -LBB1_54: +LBB1_56: WORD $0x03c6; BYTE $0x65 // movb $101, (%rbx) - WORD $0x8545; BYTE $0xf6 // testl %r14d, %r14d - LONG $0x011d8e0f; WORD $0x0000 // jle LBB1_55, $285(%rip) - WORD $0xff41; BYTE $0xce // decl %r14d + LONG $0xff458d41 // leal $-1(%r13), %eax + WORD $0x8545; BYTE $0xed // testl %r13d, %r13d + LONG $0x01518e0f; WORD $0x0000 // jle LBB1_57, $337(%rip) LONG $0x2b0143c6 // movb $43, $1(%rbx) - WORD $0x8944; BYTE $0xf0 // movl %r14d, %eax WORD $0xf883; BYTE $0x64 // cmpl $100, %eax - LONG $0x011f820f; WORD $0x0000 // jb LBB1_59, $287(%rip) + LONG $0x01538c0f; WORD $0x0000 // jl LBB1_61, $339(%rip) -LBB1_58: +LBB1_60: WORD $0xc189 // movl %eax, %ecx LONG $0xcccccdba; BYTE $0xcc // movl $3435973837, %edx LONG $0xd1af0f48 // imulq %rcx, %rdx @@ -425,485 +335,422 @@ LBB1_58: WORD $0x0c8d; BYTE $0x12 // leal (%rdx,%rdx), %ecx WORD $0x0c8d; BYTE $0x89 // leal (%rcx,%rcx,4), %ecx WORD $0xc829 // subl %ecx, %eax - LONG $0x980d8d48; WORD $0x00ae; BYTE $0x00 // leaq $44696(%rip), %rcx /* _Digits(%rip) */ + LONG $0xf40d8d48; WORD $0x00b8; BYTE $0x00 // leaq $47348(%rip), %rcx /* _Digits(%rip) */ LONG $0x510cb70f // movzwl (%rcx,%rdx,2), %ecx LONG $0x024b8966 // movw %cx, $2(%rbx) WORD $0x300c // orb $48, %al WORD $0x4388; BYTE $0x04 // movb %al, $4(%rbx) LONG $0x05c38348 // addq $5, %rbx - LONG $0x000663e9; BYTE $0x00 // jmp LBB1_122, $1635(%rip) + LONG $0x00066ee9; BYTE $0x00 // jmp LBB1_115, $1646(%rip) -LBB1_62: - WORD $0x8545; BYTE $0xd2 // testl %r10d, %r10d - LONG $0x0105880f; WORD $0x0000 // js LBB1_63, $261(%rip) - WORD $0x8945; BYTE $0xf6 // movl %r14d, %r14d - LONG $0x371c8d4b // leaq (%r15,%r14), %rbx - WORD $0x894c; BYTE $0xfe // movq %r15, %rsi - LONG $0x00068ae8; BYTE $0x00 // callq _format_integer, $1674(%rip) - WORD $0x3948; BYTE $0xd8 // cmpq %rbx, %rax - LONG $0x0151830f; WORD $0x0000 // jae LBB1_103, $337(%rip) - LONG $0xd0558b4c // movq $-48(%rbp), %r10 - WORD $0x014d; BYTE $0xd5 // addq %r10, %r13 - WORD $0x014d; BYTE $0xf5 // addq %r14, %r13 - WORD $0x2949; BYTE $0xc5 // subq %rax, %r13 - LONG $0x08fd8349 // cmpq $8, %r13 - LONG $0x01ee830f; WORD $0x0000 // jae LBB1_105, $494(%rip) - -LBB1_120: - WORD $0x8948; BYTE $0xc2 // movq %rax, %rdx - LONG $0x000302e9; BYTE $0x00 // jmp LBB1_121, $770(%rip) +LBB1_64: + WORD $0x8545; BYTE $0xc9 // testl %r9d, %r9d + LONG $0x0139880f; WORD $0x0000 // js LBB1_65, $313(%rip) + WORD $0x634d; BYTE $0xed // movslq %r13d, %r13 + LONG $0x2f1c8d4b // leaq (%r15,%r13), %rbx + WORD $0x894c; BYTE $0xfe // movq %r15, %rsi + LONG $0x0006a6e8; BYTE $0x00 // callq _format_integer, $1702(%rip) + WORD $0x3948; BYTE $0xd8 // cmpq %rbx, %rax + LONG $0x064d830f; WORD $0x0000 // jae LBB1_115, $1613(%rip) + WORD $0x014d; BYTE $0xec // addq %r13, %r12 + WORD $0x2949; BYTE $0xc4 // subq %rax, %r12 + WORD $0x014d; BYTE $0xf4 // addq %r14, %r12 + LONG $0x20fc8349 // cmpq $32, %r12 + LONG $0x031a820f; WORD $0x0000 // jb LBB1_114, $794(%rip) + WORD $0x894c; BYTE $0xe1 // movq %r12, %rcx + LONG $0xe0e18348 // andq $-32, %rcx + LONG $0xe0798d48 // leaq $-32(%rcx), %rdi + WORD $0x8948; BYTE $0xfe // movq %rdi, %rsi + LONG $0x05eec148 // shrq $5, %rsi + WORD $0xff48; BYTE $0xc6 // incq %rsi + WORD $0xf289 // movl %esi, %edx + WORD $0xe283; BYTE $0x07 // andl $7, %edx + LONG $0xe0ff8148; WORD $0x0000; BYTE $0x00 // cmpq $224, %rdi + LONG $0x01fc830f; WORD $0x0000 // jae LBB1_107, $508(%rip) + WORD $0xff31 // xorl %edi, %edi + LONG $0x000294e9; BYTE $0x00 // jmp LBB1_109, $660(%rip) LBB1_11: WORD $0xd348; BYTE $0xef // shrq %cl, %rdi QUAD $0x0001ffffffe0b848; WORD $0x0000 // movabsq $8589934560, %rax LONG $0xe41f0548; WORD $0x540b // addq $1410065439, %rax WORD $0x3948; BYTE $0xc7 // cmpq %rax, %rdi - LONG $0x012d860f; WORD $0x0000 // jbe LBB1_17, $301(%rip) + LONG $0x013f860f; WORD $0x0000 // jbe LBB1_18, $319(%rip) WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax LONG $0x0be8c148 // shrq $11, %rax LONG $0x00000bba; BYTE $0x00 // movl $11, %edx LONG $0x0edd3d48; WORD $0x02e9 // cmpq $48828125, %rax - LONG $0x019f820f; WORD $0x0000 // jb LBB1_27, $415(%rip) + LONG $0x01b1820f; WORD $0x0000 // jb LBB1_28, $433(%rip) WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax LONG $0x0ce8c148 // shrq $12, %rax LONG $0x00000cba; BYTE $0x00 // movl $12, %edx LONG $0x4a513d48; WORD $0x0e8d // cmpq $244140625, %rax - LONG $0x0187820f; WORD $0x0000 // jb LBB1_27, $391(%rip) + LONG $0x0199820f; WORD $0x0000 // jb LBB1_28, $409(%rip) WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax LONG $0x0de8c148 // shrq $13, %rax LONG $0x00000dba; BYTE $0x00 // movl $13, %edx LONG $0x73953d48; WORD $0x48c2 // cmpq $1220703125, %rax - LONG $0x016f820f; WORD $0x0000 // jb LBB1_27, $367(%rip) + LONG $0x0181820f; WORD $0x0000 // jb LBB1_28, $385(%rip) LONG $0x00000eba; BYTE $0x00 // movl $14, %edx QUAD $0x5af3107a4000b848; WORD $0x0000 // movabsq $100000000000000, %rax WORD $0x3948; BYTE $0xc7 // cmpq %rax, %rdi - LONG $0x0157820f; WORD $0x0000 // jb LBB1_27, $343(%rip) + LONG $0x0169820f; WORD $0x0000 // jb LBB1_28, $361(%rip) + LONG $0x00000fba; BYTE $0x00 // movl $15, %edx QUAD $0x8d7ea4c68000b848; WORD $0x0003 // movabsq $1000000000000000, %rax WORD $0x3948; BYTE $0xc7 // cmpq %rax, %rdi - LONG $0x000010ba; BYTE $0x00 // movl $16, %edx + LONG $0x0151820f; WORD $0x0000 // jb LBB1_28, $337(%rip) + QUAD $0x86f26fc10000b848; WORD $0x0023 // movabsq $10000000000000000, %rax + WORD $0x3948; BYTE $0xc7 // cmpq %rax, %rdi + LONG $0x000011ba; BYTE $0x00 // movl $17, %edx -LBB1_26: +LBB1_27: WORD $0xda83; BYTE $0x00 // sbbl $0, %edx - LONG $0x00013de9; BYTE $0x00 // jmp LBB1_27, $317(%rip) + LONG $0x000137e9; BYTE $0x00 // jmp LBB1_28, $311(%rip) -LBB1_55: +LBB1_57: LONG $0x2d0143c6 // movb $45, $1(%rbx) - LONG $0x000001b8; BYTE $0x00 // movl $1, %eax - WORD $0x2944; BYTE $0xf0 // subl %r14d, %eax + WORD $0xd8f7 // negl %eax WORD $0xf883; BYTE $0x64 // cmpl $100, %eax - LONG $0xfee1830f; WORD $0xffff // jae LBB1_58, $-287(%rip) + LONG $0xfead8d0f; WORD $0xffff // jge LBB1_60, $-339(%rip) -LBB1_59: +LBB1_61: WORD $0xf883; BYTE $0x0a // cmpl $10, %eax - LONG $0x0087820f; WORD $0x0000 // jb LBB1_61, $135(%rip) + LONG $0x00878c0f; WORD $0x0000 // jl LBB1_63, $135(%rip) WORD $0xc089 // movl %eax, %eax - LONG $0x850d8d48; WORD $0x00ad; BYTE $0x00 // leaq $44421(%rip), %rcx /* _Digits(%rip) */ + LONG $0xad0d8d48; WORD $0x00b7; BYTE $0x00 // leaq $47021(%rip), %rcx /* _Digits(%rip) */ LONG $0x4104b70f // movzwl (%rcx,%rax,2), %eax LONG $0x02438966 // movw %ax, $2(%rbx) LONG $0x04c38348 // addq $4, %rbx - LONG $0x000555e9; BYTE $0x00 // jmp LBB1_122, $1365(%rip) + LONG $0x00052ce9; BYTE $0x00 // jmp LBB1_115, $1324(%rip) + +LBB1_65: + WORD $0x8545; BYTE $0xed // testl %r13d, %r13d + LONG $0x03128f0f; WORD $0x0000 // jg LBB1_78, $786(%rip) + LONG $0x07c74166; WORD $0x2e30 // movw $11824, (%r15) + LONG $0x02c78349 // addq $2, %r15 + WORD $0x8545; BYTE $0xed // testl %r13d, %r13d + LONG $0x02ff890f; WORD $0x0000 // jns LBB1_78, $767(%rip) + WORD $0x8941; BYTE $0xd0 // movl %edx, %r8d + WORD $0xf741; BYTE $0xd0 // notl %r8d + WORD $0x2945; BYTE $0xc8 // subl %r9d, %r8d + WORD $0xc031 // xorl %eax, %eax + LONG $0x1ff88341 // cmpl $31, %r8d + LONG $0x02cb820f; WORD $0x0000 // jb LBB1_76, $715(%rip) + WORD $0xff49; BYTE $0xc0 // incq %r8 + WORD $0x894c; BYTE $0xc0 // movq %r8, %rax + QUAD $0x0001ffffffe0b948; WORD $0x0000 // movabsq $8589934560, %rcx + WORD $0x2148; BYTE $0xc8 // andq %rcx, %rax + LONG $0xe0488d48 // leaq $-32(%rax), %rcx + WORD $0x8948; BYTE $0xce // movq %rcx, %rsi + LONG $0x05eec148 // shrq $5, %rsi + WORD $0xff48; BYTE $0xc6 // incq %rsi + WORD $0x8941; BYTE $0xf1 // movl %esi, %r9d + LONG $0x07e18341 // andl $7, %r9d + LONG $0xe0f98148; WORD $0x0000; BYTE $0x00 // cmpq $224, %rcx + LONG $0x01ba830f; WORD $0x0000 // jae LBB1_70, $442(%rip) + WORD $0xc931 // xorl %ecx, %ecx + LONG $0x000251e9; BYTE $0x00 // jmp LBB1_72, $593(%rip) LBB1_63: - WORD $0x8545; BYTE $0xf6 // testl %r14d, %r14d - LONG $0x02fa8f0f; WORD $0x0000 // jg LBB1_76, $762(%rip) - LONG $0x07c74166; WORD $0x2e30 // movw $11824, (%r15) - LONG $0x02c78349 // addq $2, %r15 - WORD $0x8545; BYTE $0xf6 // testl %r14d, %r14d - LONG $0x02e7890f; WORD $0x0000 // jns LBB1_76, $743(%rip) - WORD $0x8941; BYTE $0xd0 // movl %edx, %r8d - WORD $0xf741; BYTE $0xd0 // notl %r8d - WORD $0x2945; BYTE $0xd0 // subl %r10d, %r8d - WORD $0xc031 // xorl %eax, %eax - LONG $0x1ff88341 // cmpl $31, %r8d - LONG $0x02bb820f; WORD $0x0000 // jb LBB1_74, $699(%rip) - WORD $0xff49; BYTE $0xc0 // incq %r8 - WORD $0x894c; BYTE $0xc0 // movq %r8, %rax - WORD $0x214c; BYTE $0xe0 // andq %r12, %rax - LONG $0xe0488d48 // leaq $-32(%rax), %rcx - WORD $0x8948; BYTE $0xce // movq %rcx, %rsi - LONG $0x05eec148 // shrq $5, %rsi - WORD $0xff48; BYTE $0xc6 // incq %rsi - WORD $0x8941; BYTE $0xf1 // movl %esi, %r9d - LONG $0x03e18341 // andl $3, %r9d - LONG $0x60f98348 // cmpq $96, %rcx - LONG $0x01f7830f; WORD $0x0000 // jae LBB1_68, $503(%rip) - WORD $0xc931 // xorl %ecx, %ecx - LONG $0xd0558b4c // movq $-48(%rbp), %r10 - LONG $0x000243e9; BYTE $0x00 // jmp LBB1_70, $579(%rip) - -LBB1_103: - LONG $0xd0558b4c // movq $-48(%rbp), %r10 - LONG $0x0004e8e9; BYTE $0x00 // jmp LBB1_122, $1256(%rip) - -LBB1_61: WORD $0x3004 // addb $48, %al WORD $0x4388; BYTE $0x02 // movb %al, $2(%rbx) LONG $0x03c38348 // addq $3, %rbx - LONG $0x0004dae9; BYTE $0x00 // jmp LBB1_122, $1242(%rip) + LONG $0x0004b1e9; BYTE $0x00 // jmp LBB1_115, $1201(%rip) -LBB1_17: +LBB1_18: LONG $0x000001ba; BYTE $0x00 // movl $1, %edx LONG $0x0aff8348 // cmpq $10, %rdi - LONG $0x007b820f; WORD $0x0000 // jb LBB1_27, $123(%rip) + LONG $0x007b820f; WORD $0x0000 // jb LBB1_28, $123(%rip) LONG $0x000002ba; BYTE $0x00 // movl $2, %edx LONG $0x64ff8348 // cmpq $100, %rdi - LONG $0x006c820f; WORD $0x0000 // jb LBB1_27, $108(%rip) + LONG $0x006c820f; WORD $0x0000 // jb LBB1_28, $108(%rip) LONG $0x000003ba; BYTE $0x00 // movl $3, %edx LONG $0xe8ff8148; WORD $0x0003; BYTE $0x00 // cmpq $1000, %rdi - LONG $0x005a820f; WORD $0x0000 // jb LBB1_27, $90(%rip) + LONG $0x005a820f; WORD $0x0000 // jb LBB1_28, $90(%rip) LONG $0x000004ba; BYTE $0x00 // movl $4, %edx LONG $0x10ff8148; WORD $0x0027; BYTE $0x00 // cmpq $10000, %rdi - LONG $0x0048820f; WORD $0x0000 // jb LBB1_27, $72(%rip) + LONG $0x0048820f; WORD $0x0000 // jb LBB1_28, $72(%rip) LONG $0x000005ba; BYTE $0x00 // movl $5, %edx LONG $0xa0ff8148; WORD $0x0186; BYTE $0x00 // cmpq $100000, %rdi - LONG $0x0036820f; WORD $0x0000 // jb LBB1_27, $54(%rip) + LONG $0x0036820f; WORD $0x0000 // jb LBB1_28, $54(%rip) LONG $0x000006ba; BYTE $0x00 // movl $6, %edx LONG $0x40ff8148; WORD $0x0f42; BYTE $0x00 // cmpq $1000000, %rdi - LONG $0x0024820f; WORD $0x0000 // jb LBB1_27, $36(%rip) + LONG $0x0024820f; WORD $0x0000 // jb LBB1_28, $36(%rip) LONG $0x000007ba; BYTE $0x00 // movl $7, %edx LONG $0x80ff8148; WORD $0x9896; BYTE $0x00 // cmpq $10000000, %rdi - LONG $0x0012820f; WORD $0x0000 // jb LBB1_27, $18(%rip) + LONG $0x0012820f; WORD $0x0000 // jb LBB1_28, $18(%rip) LONG $0x000008ba; BYTE $0x00 // movl $8, %edx LONG $0x00ff8148; WORD $0xf5e1; BYTE $0x05 // cmpq $100000000, %rdi - LONG $0x0478830f; WORD $0x0000 // jae LBB1_25, $1144(%rip) + LONG $0x0460830f; WORD $0x0000 // jae LBB1_26, $1120(%rip) -LBB1_27: +LBB1_28: WORD $0x894c; BYTE $0xfe // movq %r15, %rsi - LONG $0x000487e8; BYTE $0x00 // callq _format_integer, $1159(%rip) + LONG $0x00046fe8; BYTE $0x00 // callq _format_integer, $1135(%rip) WORD $0x8948; BYTE $0xc3 // movq %rax, %rbx - WORD $0x5d2b; BYTE $0xd0 // subl $-48(%rbp), %ebx - LONG $0x000440e9; BYTE $0x00 // jmp LBB1_123, $1088(%rip) - -LBB1_105: - LONG $0x20fd8349 // cmpq $32, %r13 - LONG $0x0007830f; WORD $0x0000 // jae LBB1_110, $7(%rip) - WORD $0xc931 // xorl %ecx, %ecx - LONG $0x0000c6e9; BYTE $0x00 // jmp LBB1_107, $198(%rip) - -LBB1_110: - WORD $0x894c; BYTE $0xe9 // movq %r13, %rcx - LONG $0xe0e18348 // andq $-32, %rcx - LONG $0xe0798d48 // leaq $-32(%rcx), %rdi - WORD $0x8948; BYTE $0xfe // movq %rdi, %rsi - LONG $0x05eec148 // shrq $5, %rsi - WORD $0xff48; BYTE $0xc6 // incq %rsi - WORD $0xf289 // movl %esi, %edx - WORD $0xe283; BYTE $0x03 // andl $3, %edx - LONG $0x60ff8348 // cmpq $96, %rdi - LONG $0x0007830f; WORD $0x0000 // jae LBB1_112, $7(%rip) - WORD $0xff31 // xorl %edi, %edi - LONG $0x00004de9; BYTE $0x00 // jmp LBB1_114, $77(%rip) - -LBB1_112: - LONG $0xfce68348 // andq $-4, %rsi - WORD $0xff31 // xorl %edi, %edi - QUAD $0xfffff902056f0f66 // movdqa $-1790(%rip), %xmm0 /* LCPI1_0(%rip) */ - WORD $0x9090 // .p2align 4, 0x90 - -LBB1_113: - LONG $0x047f0ff3; BYTE $0x38 // movdqu %xmm0, (%rax,%rdi) - LONG $0x447f0ff3; WORD $0x1038 // movdqu %xmm0, $16(%rax,%rdi) - LONG $0x447f0ff3; WORD $0x2038 // movdqu %xmm0, $32(%rax,%rdi) - LONG $0x447f0ff3; WORD $0x3038 // movdqu %xmm0, $48(%rax,%rdi) - LONG $0x447f0ff3; WORD $0x4038 // movdqu %xmm0, $64(%rax,%rdi) - LONG $0x447f0ff3; WORD $0x5038 // movdqu %xmm0, $80(%rax,%rdi) - LONG $0x447f0ff3; WORD $0x6038 // movdqu %xmm0, $96(%rax,%rdi) - LONG $0x447f0ff3; WORD $0x7038 // movdqu %xmm0, $112(%rax,%rdi) - LONG $0x80ef8348 // subq $-128, %rdi - LONG $0xfcc68348 // addq $-4, %rsi - LONG $0xffc3850f; WORD $0xffff // jne LBB1_113, $-61(%rip) + LONG $0x000417e9; BYTE $0x00 // jmp LBB1_115, $1047(%rip) -LBB1_114: - WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx - LONG $0x0032840f; WORD $0x0000 // je LBB1_117, $50(%rip) - LONG $0x07348d48 // leaq (%rdi,%rax), %rsi - LONG $0x10c68348 // addq $16, %rsi - LONG $0x05e2c148 // shlq $5, %rdx +LBB1_107: + LONG $0xf8e68348 // andq $-8, %rsi + WORD $0xf748; BYTE $0xde // negq %rsi WORD $0xff31 // xorl %edi, %edi - QUAD $0xfffff8a4056f0f66 // movdqa $-1884(%rip), %xmm0 /* LCPI1_0(%rip) */ - LONG $0x90909090 // .p2align 4, 0x90 + QUAD $0xfffff936056f0f66 // movdqa $-1738(%rip), %xmm0 /* LCPI1_0(%rip) */ + LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 -LBB1_116: - LONG $0x447f0ff3; WORD $0xf03e // movdqu %xmm0, $-16(%rsi,%rdi) - LONG $0x047f0ff3; BYTE $0x3e // movdqu %xmm0, (%rsi,%rdi) - LONG $0x20c78348 // addq $32, %rdi - WORD $0x3948; BYTE $0xfa // cmpq %rdi, %rdx - LONG $0xffe8850f; WORD $0xffff // jne LBB1_116, $-24(%rip) +LBB1_108: + LONG $0x047f0ff3; BYTE $0x38 // movdqu %xmm0, (%rax,%rdi) + LONG $0x447f0ff3; WORD $0x1038 // movdqu %xmm0, $16(%rax,%rdi) + LONG $0x447f0ff3; WORD $0x2038 // movdqu %xmm0, $32(%rax,%rdi) + LONG $0x447f0ff3; WORD $0x3038 // movdqu %xmm0, $48(%rax,%rdi) + LONG $0x447f0ff3; WORD $0x4038 // movdqu %xmm0, $64(%rax,%rdi) + LONG $0x447f0ff3; WORD $0x5038 // movdqu %xmm0, $80(%rax,%rdi) + LONG $0x447f0ff3; WORD $0x6038 // movdqu %xmm0, $96(%rax,%rdi) + LONG $0x447f0ff3; WORD $0x7038 // movdqu %xmm0, $112(%rax,%rdi) + QUAD $0x00008038847f0ff3; BYTE $0x00 // movdqu %xmm0, $128(%rax,%rdi) + QUAD $0x00009038847f0ff3; BYTE $0x00 // movdqu %xmm0, $144(%rax,%rdi) + QUAD $0x0000a038847f0ff3; BYTE $0x00 // movdqu %xmm0, $160(%rax,%rdi) + QUAD $0x0000b038847f0ff3; BYTE $0x00 // movdqu %xmm0, $176(%rax,%rdi) + QUAD $0x0000c038847f0ff3; BYTE $0x00 // movdqu %xmm0, $192(%rax,%rdi) + QUAD $0x0000d038847f0ff3; BYTE $0x00 // movdqu %xmm0, $208(%rax,%rdi) + QUAD $0x0000e038847f0ff3; BYTE $0x00 // movdqu %xmm0, $224(%rax,%rdi) + QUAD $0x0000f038847f0ff3; BYTE $0x00 // movdqu %xmm0, $240(%rax,%rdi) + LONG $0x00c78148; WORD $0x0001; BYTE $0x00 // addq $256, %rdi + LONG $0x08c68348 // addq $8, %rsi + LONG $0xff78850f; WORD $0xffff // jne LBB1_108, $-136(%rip) + +LBB1_109: + WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx + LONG $0x0035840f; WORD $0x0000 // je LBB1_112, $53(%rip) + LONG $0x07748d48; BYTE $0x10 // leaq $16(%rdi,%rax), %rsi + WORD $0xf748; BYTE $0xda // negq %rdx + QUAD $0xfffff88f056f0f66 // movdqa $-1905(%rip), %xmm0 /* LCPI1_0(%rip) */ + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 -LBB1_117: - WORD $0x3949; BYTE $0xcd // cmpq %rcx, %r13 - LONG $0x0370840f; WORD $0x0000 // je LBB1_122, $880(%rip) - LONG $0x18c5f641 // testb $24, %r13b - LONG $0x0059840f; WORD $0x0000 // je LBB1_119, $89(%rip) +LBB1_111: + LONG $0x467f0ff3; BYTE $0xf0 // movdqu %xmm0, $-16(%rsi) + LONG $0x067f0ff3 // movdqu %xmm0, (%rsi) + LONG $0x20c68348 // addq $32, %rsi + WORD $0xff48; BYTE $0xc2 // incq %rdx + LONG $0xffea850f; WORD $0xffff // jne LBB1_111, $-22(%rip) -LBB1_107: - WORD $0x894c; BYTE $0xee // movq %r13, %rsi - LONG $0xf8e68348 // andq $-8, %rsi - WORD $0x8948; BYTE $0xc2 // movq %rax, %rdx - WORD $0x0148; BYTE $0xf2 // addq %rsi, %rdx - QUAD $0x303030303030bf48; WORD $0x3030 // movabsq $3472328296227680304, %rdi +LBB1_112: + WORD $0x394c; BYTE $0xe1 // cmpq %r12, %rcx + LONG $0x0331840f; WORD $0x0000 // je LBB1_115, $817(%rip) + WORD $0x0148; BYTE $0xc8 // addq %rcx, %rax QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 -LBB1_108: - LONG $0x083c8948 // movq %rdi, (%rax,%rcx) - LONG $0x08c18348 // addq $8, %rcx - WORD $0x3948; BYTE $0xce // cmpq %rcx, %rsi - LONG $0xffef850f; WORD $0xffff // jne LBB1_108, $-17(%rip) - WORD $0x3949; BYTE $0xf5 // cmpq %rsi, %r13 - LONG $0x0327840f; WORD $0x0000 // je LBB1_122, $807(%rip) - LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 +LBB1_114: + WORD $0x00c6; BYTE $0x30 // movb $48, (%rax) + WORD $0xff48; BYTE $0xc0 // incq %rax + WORD $0x3948; BYTE $0xc3 // cmpq %rax, %rbx + LONG $0xfff1850f; WORD $0xffff // jne LBB1_114, $-15(%rip) + LONG $0x00030ce9; BYTE $0x00 // jmp LBB1_115, $780(%rip) -LBB1_121: - WORD $0x02c6; BYTE $0x30 // movb $48, (%rdx) - WORD $0xff48; BYTE $0xc2 // incq %rdx - WORD $0x3948; BYTE $0xda // cmpq %rbx, %rdx - LONG $0xfff1820f; WORD $0xffff // jb LBB1_121, $-15(%rip) - LONG $0x00030de9; BYTE $0x00 // jmp LBB1_122, $781(%rip) - -LBB1_119: - WORD $0x0148; BYTE $0xc8 // addq %rcx, %rax - LONG $0xfffcdae9; BYTE $0xff // jmp LBB1_120, $-806(%rip) - -LBB1_68: - LONG $0xfce68348 // andq $-4, %rsi - LONG $0xd0558b4c // movq $-48(%rbp), %r10 - LONG $0x2a1c8d4b // leaq (%r10,%r13), %rbx - LONG $0x72c38348 // addq $114, %rbx +LBB1_70: + QUAD $0x000000f2349c8d4b // leaq $242(%r12,%r14), %rbx + LONG $0xf8e68348 // andq $-8, %rsi + WORD $0xf748; BYTE $0xde // negq %rsi WORD $0xc931 // xorl %ecx, %ecx - QUAD $0xfffff7fa056f0f66 // movdqa $-2054(%rip), %xmm0 /* LCPI1_0(%rip) */ - -LBB1_69: - LONG $0x447f0ff3; WORD $0x900b // movdqu %xmm0, $-112(%rbx,%rcx) - LONG $0x447f0ff3; WORD $0xa00b // movdqu %xmm0, $-96(%rbx,%rcx) - LONG $0x447f0ff3; WORD $0xb00b // movdqu %xmm0, $-80(%rbx,%rcx) - LONG $0x447f0ff3; WORD $0xc00b // movdqu %xmm0, $-64(%rbx,%rcx) - LONG $0x447f0ff3; WORD $0xd00b // movdqu %xmm0, $-48(%rbx,%rcx) - LONG $0x447f0ff3; WORD $0xe00b // movdqu %xmm0, $-32(%rbx,%rcx) - LONG $0x447f0ff3; WORD $0xf00b // movdqu %xmm0, $-16(%rbx,%rcx) - LONG $0x047f0ff3; BYTE $0x0b // movdqu %xmm0, (%rbx,%rcx) - LONG $0x80e98348 // subq $-128, %rcx - LONG $0xfcc68348 // addq $-4, %rsi - LONG $0xffc3850f; WORD $0xffff // jne LBB1_69, $-61(%rip) + QUAD $0xfffff823056f0f66 // movdqa $-2013(%rip), %xmm0 /* LCPI1_0(%rip) */ + +LBB1_71: + QUAD $0xffff100b847f0ff3; BYTE $0xff // movdqu %xmm0, $-240(%rbx,%rcx) + QUAD $0xffff200b847f0ff3; BYTE $0xff // movdqu %xmm0, $-224(%rbx,%rcx) + QUAD $0xffff300b847f0ff3; BYTE $0xff // movdqu %xmm0, $-208(%rbx,%rcx) + QUAD $0xffff400b847f0ff3; BYTE $0xff // movdqu %xmm0, $-192(%rbx,%rcx) + QUAD $0xffff500b847f0ff3; BYTE $0xff // movdqu %xmm0, $-176(%rbx,%rcx) + QUAD $0xffff600b847f0ff3; BYTE $0xff // movdqu %xmm0, $-160(%rbx,%rcx) + QUAD $0xffff700b847f0ff3; BYTE $0xff // movdqu %xmm0, $-144(%rbx,%rcx) + LONG $0x447f0ff3; WORD $0x800b // movdqu %xmm0, $-128(%rbx,%rcx) + LONG $0x447f0ff3; WORD $0x900b // movdqu %xmm0, $-112(%rbx,%rcx) + LONG $0x447f0ff3; WORD $0xa00b // movdqu %xmm0, $-96(%rbx,%rcx) + LONG $0x447f0ff3; WORD $0xb00b // movdqu %xmm0, $-80(%rbx,%rcx) + LONG $0x447f0ff3; WORD $0xc00b // movdqu %xmm0, $-64(%rbx,%rcx) + LONG $0x447f0ff3; WORD $0xd00b // movdqu %xmm0, $-48(%rbx,%rcx) + LONG $0x447f0ff3; WORD $0xe00b // movdqu %xmm0, $-32(%rbx,%rcx) + LONG $0x447f0ff3; WORD $0xf00b // movdqu %xmm0, $-16(%rbx,%rcx) + LONG $0x047f0ff3; BYTE $0x0b // movdqu %xmm0, (%rbx,%rcx) + LONG $0x00c18148; WORD $0x0001; BYTE $0x00 // addq $256, %rcx + LONG $0x08c68348 // addq $8, %rsi + LONG $0xff7b850f; WORD $0xffff // jne LBB1_71, $-133(%rip) -LBB1_70: +LBB1_72: WORD $0x854d; BYTE $0xc9 // testq %r9, %r9 - LONG $0x0030840f; WORD $0x0000 // je LBB1_73, $48(%rip) - WORD $0x014c; BYTE $0xe9 // addq %r13, %rcx - WORD $0x014c; BYTE $0xd1 // addq %r10, %rcx - LONG $0x12c18348 // addq $18, %rcx - LONG $0x05e1c149 // shlq $5, %r9 - WORD $0xf631 // xorl %esi, %esi - QUAD $0xfffff79c056f0f66 // movdqa $-2148(%rip), %xmm0 /* LCPI1_0(%rip) */ + LONG $0x0029840f; WORD $0x0000 // je LBB1_75, $41(%rip) + WORD $0x014c; BYTE $0xe1 // addq %r12, %rcx + LONG $0x0e4c8d49; BYTE $0x12 // leaq $18(%r14,%rcx), %rcx + WORD $0xf749; BYTE $0xd9 // negq %r9 + QUAD $0xfffff782056f0f66 // movdqa $-2174(%rip), %xmm0 /* LCPI1_0(%rip) */ -LBB1_72: - LONG $0x447f0ff3; WORD $0xf031 // movdqu %xmm0, $-16(%rcx,%rsi) - LONG $0x047f0ff3; BYTE $0x31 // movdqu %xmm0, (%rcx,%rsi) - LONG $0x20c68348 // addq $32, %rsi - WORD $0x3949; BYTE $0xf1 // cmpq %rsi, %r9 - LONG $0xffe8850f; WORD $0xffff // jne LBB1_72, $-24(%rip) +LBB1_74: + LONG $0x417f0ff3; BYTE $0xf0 // movdqu %xmm0, $-16(%rcx) + LONG $0x017f0ff3 // movdqu %xmm0, (%rcx) + LONG $0x20c18348 // addq $32, %rcx + WORD $0xff49; BYTE $0xc1 // incq %r9 + LONG $0xffea850f; WORD $0xffff // jne LBB1_74, $-22(%rip) -LBB1_73: +LBB1_75: WORD $0x0149; BYTE $0xc7 // addq %rax, %r15 WORD $0x3949; BYTE $0xc0 // cmpq %rax, %r8 - LONG $0x0017840f; WORD $0x0000 // je LBB1_76, $23(%rip) + LONG $0x001f840f; WORD $0x0000 // je LBB1_78, $31(%rip) -LBB1_74: - WORD $0x0144; BYTE $0xf0 // addl %r14d, %eax - WORD $0xd8f7 // negl %eax - WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 +LBB1_76: + WORD $0x0144; BYTE $0xe8 // addl %r13d, %eax + WORD $0xd8f7 // negl %eax + QUAD $0x9090909090909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 -LBB1_75: +LBB1_77: LONG $0x3007c641 // movb $48, (%r15) WORD $0xff49; BYTE $0xc7 // incq %r15 WORD $0xc8ff // decl %eax - LONG $0xfff1850f; WORD $0xffff // jne LBB1_75, $-15(%rip) + LONG $0xfff1850f; WORD $0xffff // jne LBB1_77, $-15(%rip) -LBB1_76: - WORD $0x894c; BYTE $0xfe // movq %r15, %rsi - LONG $0x007279e8; BYTE $0x00 // callq _format_significand, $29305(%rip) - WORD $0xc389 // movl %eax, %ebx - WORD $0x2844; BYTE $0xfb // subb %r15b, %bl - WORD $0x2844; BYTE $0xf3 // subb %r14b, %bl - LONG $0x3e2c8d47 // leal (%r14,%r15), %r13d - WORD $0x2941; BYTE $0xc5 // subl %eax, %r13d - LONG $0xff458d45 // leal $-1(%r13), %r8d - LONG $0xfe7d8d41 // leal $-2(%r13), %edi - WORD $0xc931 // xorl %ecx, %ecx +LBB1_78: + WORD $0x894c; BYTE $0xfe // movq %r15, %rsi + LONG $0x007f99e8; BYTE $0x00 // callq _format_significand, $32665(%rip) + QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90 - // .p2align 4, 0x90 -LBB1_77: +LBB1_79: + LONG $0x30ff7880 // cmpb $48, $-1(%rax) + LONG $0xff408d48 // leaq $-1(%rax), %rax + LONG $0xfff2840f; WORD $0xffff // je LBB1_79, $-14(%rip) + LONG $0x01588d48 // leaq $1(%rax), %rbx + WORD $0x8545; BYTE $0xed // testl %r13d, %r13d + LONG $0x01e58e0f; WORD $0x0000 // jle LBB1_115, $485(%rip) WORD $0xda89 // movl %ebx, %edx - WORD $0x5a8d; BYTE $0x03 // leal $3(%rdx), %ebx - WORD $0xc7ff // incl %edi - LONG $0xff087c80; BYTE $0x30 // cmpb $48, $-1(%rax,%rcx) - LONG $0xff498d48 // leaq $-1(%rcx), %rcx - LONG $0xffea840f; WORD $0xffff // je LBB1_77, $-22(%rip) - LONG $0x081c8d48 // leaq (%rax,%rcx), %rbx - WORD $0xff48; BYTE $0xc3 // incq %rbx - WORD $0x8545; BYTE $0xf6 // testl %r14d, %r14d - LONG $0xd0558b4c // movq $-48(%rbp), %r10 - LONG $0x02078e0f; WORD $0x0000 // jle LBB1_122, $519(%rip) - WORD $0xc689 // movl %eax, %esi - WORD $0x2944; BYTE $0xfe // subl %r15d, %esi - WORD $0xce01 // addl %ecx, %esi - WORD $0xc6ff // incl %esi - WORD $0x3941; BYTE $0xf6 // cmpl %esi, %r14d - LONG $0x00308d0f; WORD $0x0000 // jge LBB1_80, $48(%rip) - WORD $0x8941; BYTE $0xc1 // movl %eax, %r9d - WORD $0x2945; BYTE $0xf1 // subl %r14d, %r9d - WORD $0x2945; BYTE $0xf9 // subl %r15d, %r9d - WORD $0xff41; BYTE $0xc1 // incl %r9d - LONG $0x093c8d49 // leaq (%r9,%rcx), %rdi - WORD $0xff85 // testl %edi, %edi - LONG $0x00e48e0f; WORD $0x0000 // jle LBB1_99, $228(%rip) - WORD $0x8941; BYTE $0xf8 // movl %edi, %r8d - LONG $0xff588d49 // leaq $-1(%r8), %rbx - LONG $0x03fb8348 // cmpq $3, %rbx - LONG $0x0069830f; WORD $0x0000 // jae LBB1_100, $105(%rip) - WORD $0xdb31 // xorl %ebx, %ebx - LONG $0x000090e9; BYTE $0x00 // jmp LBB1_96, $144(%rip) - -LBB1_80: - WORD $0x8945; BYTE $0xc3 // movl %r8d, %r11d - WORD $0x2949; BYTE $0xcb // subq %rcx, %r11 - WORD $0x8545; BYTE $0xdb // testl %r11d, %r11d - LONG $0x01b68e0f; WORD $0x0000 // jle LBB1_122, $438(%rip) - WORD $0x0145; BYTE $0xfe // addl %r15d, %r14d - WORD $0x2941; BYTE $0xc6 // subl %eax, %r14d - LONG $0xfec68341 // addl $-2, %r14d - WORD $0x2949; BYTE $0xce // subq %rcx, %r14 + WORD $0x2944; BYTE $0xfa // subl %r15d, %edx + WORD $0x8944; BYTE $0xe9 // movl %r13d, %ecx + WORD $0xd129 // subl %edx, %ecx + LONG $0x00258d0f; WORD $0x0000 // jge LBB1_82, $37(%rip) + WORD $0x2944; BYTE $0xea // subl %r13d, %edx + LONG $0x00c48e0f; WORD $0x0000 // jle LBB1_100, $196(%rip) + WORD $0xd689 // movl %edx, %esi + LONG $0xff568d48 // leaq $-1(%rsi), %rdx + WORD $0xf189 // movl %esi, %ecx + WORD $0xe183; BYTE $0x03 // andl $3, %ecx + LONG $0x03fa8348 // cmpq $3, %rdx + LONG $0x005c830f; WORD $0x0000 // jae LBB1_101, $92(%rip) WORD $0xd231 // xorl %edx, %edx - LONG $0x1ffe8341 // cmpl $31, %r14d - LONG $0x018c820f; WORD $0x0000 // jb LBB1_91, $396(%rip) - LONG $0xfec58341 // addl $-2, %r13d - WORD $0x2949; BYTE $0xcd // subq %rcx, %r13 - WORD $0x8945; BYTE $0xf0 // movl %r14d, %r8d - WORD $0xff49; BYTE $0xc0 // incq %r8 - WORD $0x214d; BYTE $0xc4 // andq %r8, %r12 - WORD $0x8941; BYTE $0xf9 // movl %edi, %r9d - WORD $0xff49; BYTE $0xc1 // incq %r9 - LONG $0xe0e18349 // andq $-32, %r9 - LONG $0x24548d49; BYTE $0xe0 // leaq $-32(%r12), %rdx - WORD $0x8949; BYTE $0xd2 // movq %rdx, %r10 - LONG $0x05eac149 // shrq $5, %r10 - WORD $0xff49; BYTE $0xc2 // incq %r10 - LONG $0x60fa8348 // cmpq $96, %rdx - LONG $0x0086830f; WORD $0x0000 // jae LBB1_84, $134(%rip) - WORD $0xdb31 // xorl %ebx, %ebx - LONG $0x0000e4e9; BYTE $0x00 // jmp LBB1_86, $228(%rip) - -LBB1_100: - WORD $0x0149; BYTE $0xc9 // addq %rcx, %r9 - LONG $0xfce18341 // andl $-4, %r9d - WORD $0xf749; BYTE $0xd9 // negq %r9 - WORD $0xdb31 // xorl %ebx, %ebx - LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 + LONG $0x000078e9; BYTE $0x00 // jmp LBB1_97, $120(%rip) + +LBB1_82: + LONG $0x01aa8e0f; WORD $0x0000 // jle LBB1_115, $426(%rip) + WORD $0x0145; BYTE $0xfd // addl %r15d, %r13d + WORD $0x8941; BYTE $0xd8 // movl %ebx, %r8d + WORD $0xf741; BYTE $0xd0 // notl %r8d + WORD $0x0145; BYTE $0xe8 // addl %r13d, %r8d + WORD $0xd231 // xorl %edx, %edx + LONG $0x1ef88341 // cmpl $30, %r8d + LONG $0x0182860f; WORD $0x0000 // jbe LBB1_92, $386(%rip) + WORD $0xff49; BYTE $0xc0 // incq %r8 + QUAD $0x0001ffffffe0b949; WORD $0x0000 // movabsq $8589934560, %r9 + WORD $0x214d; BYTE $0xc1 // andq %r8, %r9 + LONG $0xe0518d49 // leaq $-32(%r9), %rdx + WORD $0x8948; BYTE $0xd7 // movq %rdx, %rdi + LONG $0x05efc148 // shrq $5, %rdi + WORD $0xff48; BYTE $0xc7 // incq %rdi + WORD $0xfe89 // movl %edi, %esi + WORD $0xe683; BYTE $0x07 // andl $7, %esi + LONG $0xe0fa8148; WORD $0x0000; BYTE $0x00 // cmpq $224, %rdx + LONG $0x006e830f; WORD $0x0000 // jae LBB1_86, $110(%rip) + WORD $0xd231 // xorl %edx, %edx + LONG $0x000101e9; BYTE $0x00 // jmp LBB1_88, $257(%rip) LBB1_101: - LONG $0x183c8d48 // leaq (%rax,%rbx), %rdi - LONG $0xfd39748b // movl $-3(%rcx,%rdi), %esi - LONG $0xfe397489 // movl %esi, $-2(%rcx,%rdi) - LONG $0xfcc38348 // addq $-4, %rbx - WORD $0x3949; BYTE $0xd9 // cmpq %rbx, %r9 - LONG $0xffe7850f; WORD $0xffff // jne LBB1_101, $-25(%rip) - WORD $0xf748; BYTE $0xdb // negq %rbx - -LBB1_96: - LONG $0x03c0f641 // testb $3, %r8b - LONG $0x0032840f; WORD $0x0000 // je LBB1_99, $50(%rip) - LONG $0xc2b60f44 // movzbl %dl, %r8d - LONG $0x03e08341 // andl $3, %r8d - WORD $0xf749; BYTE $0xd8 // negq %r8 - WORD $0x8948; BYTE $0xc6 // movq %rax, %rsi - WORD $0x2948; BYTE $0xde // subq %rbx, %rsi - WORD $0xff31 // xorl %edi, %edi - LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + WORD $0xe683; BYTE $0xfc // andl $-4, %esi + WORD $0xf748; BYTE $0xde // negq %rsi + WORD $0xd231 // xorl %edx, %edx + WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 -LBB1_98: - LONG $0x3e1c8d48 // leaq (%rsi,%rdi), %rbx - LONG $0x1914b60f // movzbl (%rcx,%rbx), %edx - LONG $0x01195488 // movb %dl, $1(%rcx,%rbx) - WORD $0xff48; BYTE $0xcf // decq %rdi - WORD $0x3949; BYTE $0xf8 // cmpq %rdi, %r8 - LONG $0xffe8850f; WORD $0xffff // jne LBB1_98, $-24(%rip) +LBB1_102: + LONG $0xfd107c8b // movl $-3(%rax,%rdx), %edi + LONG $0xfe107c89 // movl %edi, $-2(%rax,%rdx) + LONG $0xfcc28348 // addq $-4, %rdx + WORD $0x3948; BYTE $0xd6 // cmpq %rdx, %rsi + LONG $0xffeb850f; WORD $0xffff // jne LBB1_102, $-21(%rip) + WORD $0xf748; BYTE $0xda // negq %rdx + +LBB1_97: + WORD $0x8548; BYTE $0xc9 // testq %rcx, %rcx + LONG $0x0027840f; WORD $0x0000 // je LBB1_100, $39(%rip) + WORD $0xf748; BYTE $0xda // negq %rdx + WORD $0xf748; BYTE $0xd9 // negq %rcx + WORD $0xf631 // xorl %esi, %esi + LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 LBB1_99: - WORD $0x8944; BYTE $0xf2 // movl %r14d, %edx - LONG $0x1704c641; BYTE $0x2e // movb $46, (%r15,%rdx) - LONG $0x081c8d48 // leaq (%rax,%rcx), %rbx - LONG $0x02c38348 // addq $2, %rbx - LONG $0x0000e4e9; BYTE $0x00 // jmp LBB1_122, $228(%rip) - -LBB1_84: - WORD $0x8944; BYTE $0xef // movl %r13d, %edi - WORD $0xff48; BYTE $0xc7 // incq %rdi - LONG $0xe0e78348 // andq $-32, %rdi - LONG $0xe0c78348 // addq $-32, %rdi - LONG $0x05efc148 // shrq $5, %rdi - WORD $0xff48; BYTE $0xc7 // incq %rdi - LONG $0xfce78348 // andq $-4, %rdi - WORD $0xdb31 // xorl %ebx, %ebx - QUAD $0xfffff5d0056f0f66 // movdqa $-2608(%rip), %xmm0 /* LCPI1_0(%rip) */ - -LBB1_85: - LONG $0x18148d48 // leaq (%rax,%rbx), %rdx - LONG $0x447f0ff3; WORD $0x0111 // movdqu %xmm0, $1(%rcx,%rdx) - LONG $0x447f0ff3; WORD $0x1111 // movdqu %xmm0, $17(%rcx,%rdx) - LONG $0x447f0ff3; WORD $0x2111 // movdqu %xmm0, $33(%rcx,%rdx) - LONG $0x447f0ff3; WORD $0x3111 // movdqu %xmm0, $49(%rcx,%rdx) - LONG $0x447f0ff3; WORD $0x4111 // movdqu %xmm0, $65(%rcx,%rdx) - LONG $0x447f0ff3; WORD $0x5111 // movdqu %xmm0, $81(%rcx,%rdx) - LONG $0x447f0ff3; WORD $0x6111 // movdqu %xmm0, $97(%rcx,%rdx) - LONG $0x447f0ff3; WORD $0x7111 // movdqu %xmm0, $113(%rcx,%rdx) - LONG $0x80eb8348 // subq $-128, %rbx - LONG $0xfcc78348 // addq $-4, %rdi - LONG $0xffbe850f; WORD $0xffff // jne LBB1_85, $-66(%rip) + LONG $0x323c8d48 // leaq (%rdx,%rsi), %rdi + LONG $0x381cb60f // movzbl (%rax,%rdi), %ebx + LONG $0x01385c88 // movb %bl, $1(%rax,%rdi) + WORD $0xff48; BYTE $0xce // decq %rsi + WORD $0x3948; BYTE $0xf1 // cmpq %rsi, %rcx + LONG $0xffe8850f; WORD $0xffff // jne LBB1_99, $-24(%rip) + +LBB1_100: + WORD $0x6349; BYTE $0xcd // movslq %r13d, %rcx + LONG $0x0f04c641; BYTE $0x2e // movb $46, (%r15,%rcx) + LONG $0x02c08348 // addq $2, %rax + WORD $0x8948; BYTE $0xc3 // movq %rax, %rbx + LONG $0x0000f4e9; BYTE $0x00 // jmp LBB1_115, $244(%rip) LBB1_86: - WORD $0x0149; BYTE $0xc1 // addq %rax, %r9 - LONG $0x03c2f641 // testb $3, %r10b - LONG $0x004a840f; WORD $0x0000 // je LBB1_89, $74(%rip) - WORD $0xfe41; BYTE $0xc5 // incb %r13b - LONG $0x60e58041 // andb $96, %r13b - LONG $0xe0c58041 // addb $-32, %r13b - LONG $0x05edc041 // shrb $5, %r13b - WORD $0xfe41; BYTE $0xc5 // incb %r13b - LONG $0xd5b60f41 // movzbl %r13b, %edx - WORD $0xe283; BYTE $0x03 // andl $3, %edx - LONG $0x05e2c148 // shlq $5, %rdx - WORD $0x0148; BYTE $0xd8 // addq %rbx, %rax - LONG $0x11c08348 // addq $17, %rax - WORD $0xf631 // xorl %esi, %esi - QUAD $0xfffff553056f0f66 // movdqa $-2733(%rip), %xmm0 /* LCPI1_0(%rip) */ + LONG $0xf8e78348 // andq $-8, %rdi + WORD $0xf748; BYTE $0xdf // negq %rdi + WORD $0xd231 // xorl %edx, %edx + QUAD $0xfffff613056f0f66 // movdqa $-2541(%rip), %xmm0 /* LCPI1_0(%rip) */ + +LBB1_87: + LONG $0x447f0ff3; WORD $0x0110 // movdqu %xmm0, $1(%rax,%rdx) + LONG $0x447f0ff3; WORD $0x1110 // movdqu %xmm0, $17(%rax,%rdx) + LONG $0x447f0ff3; WORD $0x2110 // movdqu %xmm0, $33(%rax,%rdx) + LONG $0x447f0ff3; WORD $0x3110 // movdqu %xmm0, $49(%rax,%rdx) + LONG $0x447f0ff3; WORD $0x4110 // movdqu %xmm0, $65(%rax,%rdx) + LONG $0x447f0ff3; WORD $0x5110 // movdqu %xmm0, $81(%rax,%rdx) + LONG $0x447f0ff3; WORD $0x6110 // movdqu %xmm0, $97(%rax,%rdx) + LONG $0x447f0ff3; WORD $0x7110 // movdqu %xmm0, $113(%rax,%rdx) + QUAD $0x00008110847f0ff3; BYTE $0x00 // movdqu %xmm0, $129(%rax,%rdx) + QUAD $0x00009110847f0ff3; BYTE $0x00 // movdqu %xmm0, $145(%rax,%rdx) + QUAD $0x0000a110847f0ff3; BYTE $0x00 // movdqu %xmm0, $161(%rax,%rdx) + QUAD $0x0000b110847f0ff3; BYTE $0x00 // movdqu %xmm0, $177(%rax,%rdx) + QUAD $0x0000c110847f0ff3; BYTE $0x00 // movdqu %xmm0, $193(%rax,%rdx) + QUAD $0x0000d110847f0ff3; BYTE $0x00 // movdqu %xmm0, $209(%rax,%rdx) + QUAD $0x0000e110847f0ff3; BYTE $0x00 // movdqu %xmm0, $225(%rax,%rdx) + QUAD $0x0000f110847f0ff3; BYTE $0x00 // movdqu %xmm0, $241(%rax,%rdx) + LONG $0x00c28148; WORD $0x0001; BYTE $0x00 // addq $256, %rdx + LONG $0x08c78348 // addq $8, %rdi + LONG $0xff77850f; WORD $0xffff // jne LBB1_87, $-137(%rip) LBB1_88: - LONG $0x303c8d48 // leaq (%rax,%rsi), %rdi - LONG $0x447f0ff3; WORD $0xf039 // movdqu %xmm0, $-16(%rcx,%rdi) - LONG $0x047f0ff3; BYTE $0x39 // movdqu %xmm0, (%rcx,%rdi) - LONG $0x20c68348 // addq $32, %rsi - WORD $0x3948; BYTE $0xf2 // cmpq %rsi, %rdx - LONG $0xffe4850f; WORD $0xffff // jne LBB1_88, $-28(%rip) - -LBB1_89: - LONG $0x091c8d4a // leaq (%rcx,%r9), %rbx - WORD $0xff48; BYTE $0xc3 // incq %rbx - WORD $0x394d; BYTE $0xe0 // cmpq %r12, %r8 - LONG $0xd0558b4c // movq $-48(%rbp), %r10 - LONG $0x0014840f; WORD $0x0000 // je LBB1_122, $20(%rip) - WORD $0x8944; BYTE $0xe2 // movl %r12d, %edx + LONG $0x085c8d4a; BYTE $0x01 // leaq $1(%rax,%r9), %rbx + WORD $0x8548; BYTE $0xf6 // testq %rsi, %rsi + LONG $0x0026840f; WORD $0x0000 // je LBB1_91, $38(%rip) + LONG $0x10448d48; BYTE $0x11 // leaq $17(%rax,%rdx), %rax + WORD $0xf748; BYTE $0xde // negq %rsi + QUAD $0xfffff56c056f0f66 // movdqa $-2708(%rip), %xmm0 /* LCPI1_0(%rip) */ + +LBB1_90: + LONG $0x407f0ff3; BYTE $0xf0 // movdqu %xmm0, $-16(%rax) + LONG $0x007f0ff3 // movdqu %xmm0, (%rax) + LONG $0x20c08348 // addq $32, %rax + WORD $0xff48; BYTE $0xc6 // incq %rsi + LONG $0xffea850f; WORD $0xffff // jne LBB1_90, $-22(%rip) - // .p2align 4, 0x90 LBB1_91: + WORD $0x8944; BYTE $0xca // movl %r9d, %edx + WORD $0x394d; BYTE $0xc8 // cmpq %r9, %r8 + LONG $0x001a840f; WORD $0x0000 // je LBB1_115, $26(%rip) + QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90 + +LBB1_92: WORD $0x03c6; BYTE $0x30 // movb $48, (%rbx) WORD $0xff48; BYTE $0xc3 // incq %rbx WORD $0xc2ff // incl %edx - WORD $0x3944; BYTE $0xda // cmpl %r11d, %edx - LONG $0xffef8c0f; WORD $0xffff // jl LBB1_91, $-17(%rip) + WORD $0xca39 // cmpl %ecx, %edx + LONG $0xfff08c0f; WORD $0xffff // jl LBB1_92, $-16(%rip) -LBB1_122: - WORD $0x2944; BYTE $0xd3 // subl %r10d, %ebx +LBB1_115: + WORD $0x2944; BYTE $0xf3 // subl %r14d, %ebx -LBB1_123: +LBB1_116: WORD $0xd889 // movl %ebx, %eax LONG $0x08c48348 // addq $8, %rsp BYTE $0x5b // popq %rbx @@ -914,19 +761,24 @@ LBB1_123: BYTE $0x5d // popq %rbp BYTE $0xc3 // retq +LBB1_49: + LONG $0x00ff8148; WORD $0x9aca; BYTE $0x3b // cmpq $1000000000, %rdi + LONG $0x00000aba; BYTE $0x00 // movl $10, %edx + LONG $0xfff809e9; BYTE $0xff // jmp LBB1_50, $-2039(%rip) + LBB1_1: WORD $0xdb31 // xorl %ebx, %ebx - LONG $0xffffe8e9; BYTE $0xff // jmp LBB1_123, $-24(%rip) + LONG $0xffffd7e9; BYTE $0xff // jmp LBB1_116, $-41(%rip) LBB1_5: - LONG $0xfffbcebe; BYTE $0xff // movl $-1074, %esi + LONG $0xfffbcebb; BYTE $0xff // movl $-1074, %ebx WORD $0x8948; BYTE $0xd7 // movq %rdx, %rdi - LONG $0xfff594e9; BYTE $0xff // jmp LBB1_6, $-2668(%rip) + LONG $0xfff59de9; BYTE $0xff // jmp LBB1_6, $-2659(%rip) -LBB1_25: +LBB1_26: LONG $0x00ff8148; WORD $0x9aca; BYTE $0x3b // cmpq $1000000000, %rdi LONG $0x00000aba; BYTE $0x00 // movl $10, %edx - LONG $0xfffa32e9; BYTE $0xff // jmp LBB1_26, $-1486(%rip) + LONG $0xfffa50e9; BYTE $0xff // jmp LBB1_27, $-1456(%rip) LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 _format_integer: @@ -978,7 +830,7 @@ LBB2_2: WORD $0xcf6b; BYTE $0x64 // imull $100, %edi, %ecx WORD $0xc829 // subl %ecx, %eax LONG $0xd8b70f44 // movzwl %ax, %r11d - LONG $0x300d8d48; WORD $0x00a7; BYTE $0x00 // leaq $42800(%rip), %rcx /* _Digits(%rip) */ + LONG $0x700d8d48; WORD $0x00b1; BYTE $0x00 // leaq $45424(%rip), %rcx /* _Digits(%rip) */ LONG $0x04b70f42; BYTE $0x51 // movzwl (%rcx,%r10,2), %eax LONG $0x40894166; BYTE $0xfe // movw %ax, $-2(%r8) LONG $0x04b70f42; BYTE $0x49 // movzwl (%rcx,%r9,2), %eax @@ -994,7 +846,7 @@ LBB2_2: LBB2_5: LONG $0x1759b941; WORD $0xd1b7 // movl $3518437209, %r9d - LONG $0xe9158d4c; WORD $0x00a6; BYTE $0x00 // leaq $42729(%rip), %r10 /* _Digits(%rip) */ + LONG $0x29158d4c; WORD $0x00b1; BYTE $0x00 // leaq $45353(%rip), %r10 /* _Digits(%rip) */ QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90 LBB2_6: @@ -1026,7 +878,7 @@ LBB2_7: WORD $0xc86b; BYTE $0x64 // imull $100, %eax, %ecx WORD $0xca29 // subl %ecx, %edx WORD $0xb70f; BYTE $0xca // movzwl %dx, %ecx - LONG $0x71158d48; WORD $0x00a6; BYTE $0x00 // leaq $42609(%rip), %rdx /* _Digits(%rip) */ + LONG $0xb1158d48; WORD $0x00b0; BYTE $0x00 // leaq $45233(%rip), %rdx /* _Digits(%rip) */ LONG $0x4a0cb70f // movzwl (%rdx,%rcx,2), %ecx LONG $0x4b894166; BYTE $0xfe // movw %cx, $-2(%r11) LONG $0xfec38349 // addq $-2, %r11 @@ -1036,7 +888,7 @@ LBB2_9: WORD $0xfa83; BYTE $0x0a // cmpl $10, %edx LONG $0x0018820f; WORD $0x0000 // jb LBB2_11, $24(%rip) WORD $0xd089 // movl %edx, %eax - LONG $0x500d8d48; WORD $0x00a6; BYTE $0x00 // leaq $42576(%rip), %rcx /* _Digits(%rip) */ + LONG $0x900d8d48; WORD $0x00b0; BYTE $0x00 // leaq $45200(%rip), %rcx /* _Digits(%rip) */ LONG $0x4104b70f // movzwl (%rcx,%rax,2), %eax LONG $0x43894166; BYTE $0xfe // movw %ax, $-2(%r11) WORD $0x894c; BYTE $0xc0 // movq %r8, %rax @@ -1054,100 +906,65 @@ LBB2_11: LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 _i64toa: + WORD $0x8548; BYTE $0xf6 // testq %rsi, %rsi + LONG $0x0005880f; WORD $0x0000 // js LBB3_1, $5(%rip) + LONG $0x000072e9; BYTE $0x00 // jmp _u64toa, $114(%rip) + +LBB3_1: BYTE $0x55 // pushq %rbp WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp - WORD $0x8548; BYTE $0xf6 // testq %rsi, %rsi - LONG $0x00b1880f; WORD $0x0000 // js LBB3_12, $177(%rip) - LONG $0x0ffe8148; WORD $0x0027; BYTE $0x00 // cmpq $9999, %rsi - LONG $0x00b6870f; WORD $0x0000 // ja LBB3_9, $182(%rip) - WORD $0xb70f; BYTE $0xc6 // movzwl %si, %eax - WORD $0xe8c1; BYTE $0x02 // shrl $2, %eax - LONG $0x147bc069; WORD $0x0000 // imull $5243, %eax, %eax - WORD $0xe8c1; BYTE $0x11 // shrl $17, %eax - LONG $0x00148d48 // leaq (%rax,%rax), %rdx - WORD $0xc06b; BYTE $0x64 // imull $100, %eax, %eax - WORD $0xf189 // movl %esi, %ecx - WORD $0xc129 // subl %eax, %ecx - WORD $0xb70f; BYTE $0xc9 // movzwl %cx, %ecx - WORD $0x0148; BYTE $0xc9 // addq %rcx, %rcx - LONG $0x03e8fe81; WORD $0x0000 // cmpl $1000, %esi - LONG $0x0017820f; WORD $0x0000 // jb LBB3_4, $23(%rip) - LONG $0xe3058d48; WORD $0x00a5; BYTE $0x00 // leaq $42467(%rip), %rax /* _Digits(%rip) */ - LONG $0x0204b60f // movzbl (%rdx,%rax), %eax - WORD $0x0788 // movb %al, (%rdi) - LONG $0x000001b8; BYTE $0x00 // movl $1, %eax - LONG $0x00000be9; BYTE $0x00 // jmp LBB3_5, $11(%rip) - -LBB3_4: - WORD $0xc031 // xorl %eax, %eax - WORD $0xfe83; BYTE $0x64 // cmpl $100, %esi - LONG $0x0046820f; WORD $0x0000 // jb LBB3_6, $70(%rip) - -LBB3_5: - WORD $0xb70f; BYTE $0xd2 // movzwl %dx, %edx - LONG $0x01ca8348 // orq $1, %rdx - LONG $0xba358d48; WORD $0x00a5; BYTE $0x00 // leaq $42426(%rip), %rsi /* _Digits(%rip) */ - LONG $0x3214b60f // movzbl (%rdx,%rsi), %edx - WORD $0xc689 // movl %eax, %esi - WORD $0xc0ff // incl %eax - WORD $0x1488; BYTE $0x37 // movb %dl, (%rdi,%rsi) - -LBB3_7: - LONG $0xa8158d48; WORD $0x00a5; BYTE $0x00 // leaq $42408(%rip), %rdx /* _Digits(%rip) */ - LONG $0x1114b60f // movzbl (%rcx,%rdx), %edx - WORD $0xc689 // movl %eax, %esi - WORD $0xc0ff // incl %eax - WORD $0x1488; BYTE $0x37 // movb %dl, (%rdi,%rsi) - -LBB3_8: - WORD $0xb70f; BYTE $0xc9 // movzwl %cx, %ecx - LONG $0x01c98348 // orq $1, %rcx - LONG $0x8f158d48; WORD $0x00a5; BYTE $0x00 // leaq $42383(%rip), %rdx /* _Digits(%rip) */ - LONG $0x110cb60f // movzbl (%rcx,%rdx), %ecx - WORD $0xc289 // movl %eax, %edx + WORD $0x07c6; BYTE $0x2d // movb $45, (%rdi) + WORD $0xff48; BYTE $0xc7 // incq %rdi + WORD $0xf748; BYTE $0xde // negq %rsi + LONG $0x000060e8; BYTE $0x00 // callq _u64toa, $96(%rip) WORD $0xc0ff // incl %eax - WORD $0x0c88; BYTE $0x17 // movb %cl, (%rdi,%rdx) BYTE $0x5d // popq %rbp BYTE $0xc3 // retq + QUAD $0x0000000000000000; LONG $0x00000000 // .p2align 4, 0x00 -LBB3_6: - WORD $0xc031 // xorl %eax, %eax - WORD $0xfe83; BYTE $0x0a // cmpl $10, %esi - LONG $0xffc8830f; WORD $0xffff // jae LBB3_7, $-56(%rip) - LONG $0xffffd5e9; BYTE $0xff // jmp LBB3_8, $-43(%rip) - -LBB3_12: - WORD $0x07c6; BYTE $0x2d // movb $45, (%rdi) - WORD $0xff48; BYTE $0xc7 // incq %rdi - WORD $0xf748; BYTE $0xde // negq %rsi - LONG $0x000044e8; BYTE $0x00 // callq _u64toa, $68(%rip) - WORD $0xc0ff // incl %eax - BYTE $0x5d // popq %rbp - BYTE $0xc3 // retq - -LBB3_9: - LONG $0xfffe8148; WORD $0xf5e0; BYTE $0x05 // cmpq $99999999, %rsi - LONG $0x0006870f; WORD $0x0000 // ja LBB3_10, $6(%rip) - BYTE $0x5d // popq %rbp - LONG $0x00011de9; BYTE $0x00 // jmp _u32toa_medium, $285(%rip) +LCPI4_0: + QUAD $0x00000000d1b71759 // .quad 3518437209 + QUAD $0x00000000d1b71759 // .quad 3518437209 -LBB3_10: - QUAD $0x86f26fc0ffffb848; WORD $0x0023 // movabsq $9999999999999999, %rax - WORD $0x3948; BYTE $0xc6 // cmpq %rax, %rsi - LONG $0x0006870f; WORD $0x0000 // ja LBB3_11, $6(%rip) - BYTE $0x5d // popq %rbp - LONG $0x000254e9; BYTE $0x00 // jmp _u64toa_large_sse2, $596(%rip) +LCPI4_1: + WORD $0x20c5 // .word 8389 + WORD $0x147b // .word 5243 + WORD $0x3334 // .word 13108 + WORD $0x8000 // .word 32768 + WORD $0x20c5 // .word 8389 + WORD $0x147b // .word 5243 + WORD $0x3334 // .word 13108 + WORD $0x8000 // .word 32768 -LBB3_11: - BYTE $0x5d // popq %rbp - LONG $0x0003bee9; BYTE $0x00 // jmp _u64toa_xlarge_sse2, $958(%rip) - QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 +LCPI4_2: + WORD $0x0080 // .word 128 + WORD $0x0800 // .word 2048 + WORD $0x2000 // .word 8192 + WORD $0x8000 // .word 32768 + WORD $0x0080 // .word 128 + WORD $0x0800 // .word 2048 + WORD $0x2000 // .word 8192 + WORD $0x8000 // .word 32768 + +LCPI4_3: + WORD $0x000a // .word 10 + WORD $0x000a // .word 10 + WORD $0x000a // .word 10 + WORD $0x000a // .word 10 + WORD $0x000a // .word 10 + WORD $0x000a // .word 10 + WORD $0x000a // .word 10 + WORD $0x000a // .word 10 +LCPI4_4: + QUAD $0x3030303030303030; QUAD $0x3030303030303030 // .space 16, '0000000000000000' + + // .p2align 4, 0x90 _u64toa: - LONG $0x0ffe8148; WORD $0x0027; BYTE $0x00 // cmpq $9999, %rsi - LONG $0x00a8870f; WORD $0x0000 // ja LBB4_8, $168(%rip) BYTE $0x55 // pushq %rbp WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + LONG $0x0ffe8148; WORD $0x0027; BYTE $0x00 // cmpq $9999, %rsi + LONG $0x00a2870f; WORD $0x0000 // ja LBB4_8, $162(%rip) WORD $0xb70f; BYTE $0xc6 // movzwl %si, %eax WORD $0xe8c1; BYTE $0x02 // shrl $2, %eax LONG $0x147bc069; WORD $0x0000 // imull $5243, %eax, %eax @@ -1156,186 +973,148 @@ _u64toa: WORD $0xc06b; BYTE $0x64 // imull $100, %eax, %eax WORD $0xf189 // movl %esi, %ecx WORD $0xc129 // subl %eax, %ecx - WORD $0xb70f; BYTE $0xc9 // movzwl %cx, %ecx - WORD $0x0148; BYTE $0xc9 // addq %rcx, %rcx + WORD $0xb70f; BYTE $0xc1 // movzwl %cx, %eax + WORD $0x0148; BYTE $0xc0 // addq %rax, %rax LONG $0x03e8fe81; WORD $0x0000 // cmpl $1000, %esi - LONG $0x0017820f; WORD $0x0000 // jb LBB4_3, $23(%rip) - LONG $0xdc058d48; WORD $0x00a4; BYTE $0x00 // leaq $42204(%rip), %rax /* _Digits(%rip) */ - LONG $0x0204b60f // movzbl (%rdx,%rax), %eax - WORD $0x0788 // movb %al, (%rdi) - LONG $0x000001b8; BYTE $0x00 // movl $1, %eax + LONG $0x0016820f; WORD $0x0000 // jb LBB4_3, $22(%rip) + LONG $0xac0d8d48; WORD $0x00af; BYTE $0x00 // leaq $44972(%rip), %rcx /* _Digits(%rip) */ + WORD $0x0c8a; BYTE $0x0a // movb (%rdx,%rcx), %cl + WORD $0x0f88 // movb %cl, (%rdi) + LONG $0x000001b9; BYTE $0x00 // movl $1, %ecx LONG $0x00000be9; BYTE $0x00 // jmp LBB4_4, $11(%rip) LBB4_3: - WORD $0xc031 // xorl %eax, %eax + WORD $0xc931 // xorl %ecx, %ecx WORD $0xfe83; BYTE $0x64 // cmpl $100, %esi - LONG $0x0046820f; WORD $0x0000 // jb LBB4_5, $70(%rip) + LONG $0x0045820f; WORD $0x0000 // jb LBB4_5, $69(%rip) LBB4_4: WORD $0xb70f; BYTE $0xd2 // movzwl %dx, %edx LONG $0x01ca8348 // orq $1, %rdx - LONG $0xb3358d48; WORD $0x00a4; BYTE $0x00 // leaq $42163(%rip), %rsi /* _Digits(%rip) */ - LONG $0x3214b60f // movzbl (%rdx,%rsi), %edx - WORD $0xc689 // movl %eax, %esi - WORD $0xc0ff // incl %eax + LONG $0x84358d48; WORD $0x00af; BYTE $0x00 // leaq $44932(%rip), %rsi /* _Digits(%rip) */ + WORD $0x148a; BYTE $0x32 // movb (%rdx,%rsi), %dl + WORD $0xce89 // movl %ecx, %esi + WORD $0xc1ff // incl %ecx WORD $0x1488; BYTE $0x37 // movb %dl, (%rdi,%rsi) LBB4_6: - LONG $0xa1158d48; WORD $0x00a4; BYTE $0x00 // leaq $42145(%rip), %rdx /* _Digits(%rip) */ - LONG $0x1114b60f // movzbl (%rcx,%rdx), %edx - WORD $0xc689 // movl %eax, %esi - WORD $0xc0ff // incl %eax + LONG $0x73158d48; WORD $0x00af; BYTE $0x00 // leaq $44915(%rip), %rdx /* _Digits(%rip) */ + WORD $0x148a; BYTE $0x10 // movb (%rax,%rdx), %dl + WORD $0xce89 // movl %ecx, %esi + WORD $0xc1ff // incl %ecx WORD $0x1488; BYTE $0x37 // movb %dl, (%rdi,%rsi) LBB4_7: - WORD $0xb70f; BYTE $0xc9 // movzwl %cx, %ecx - LONG $0x01c98348 // orq $1, %rcx - LONG $0x88158d48; WORD $0x00a4; BYTE $0x00 // leaq $42120(%rip), %rdx /* _Digits(%rip) */ - LONG $0x110cb60f // movzbl (%rcx,%rdx), %ecx - WORD $0xc289 // movl %eax, %edx - WORD $0xc0ff // incl %eax - WORD $0x0c88; BYTE $0x17 // movb %cl, (%rdi,%rdx) + WORD $0xb70f; BYTE $0xc0 // movzwl %ax, %eax + LONG $0x01c88348 // orq $1, %rax + LONG $0x5b158d48; WORD $0x00af; BYTE $0x00 // leaq $44891(%rip), %rdx /* _Digits(%rip) */ + WORD $0x048a; BYTE $0x10 // movb (%rax,%rdx), %al + WORD $0xca89 // movl %ecx, %edx + WORD $0xc1ff // incl %ecx + WORD $0x0488; BYTE $0x17 // movb %al, (%rdi,%rdx) + WORD $0xc889 // movl %ecx, %eax BYTE $0x5d // popq %rbp BYTE $0xc3 // retq LBB4_5: - WORD $0xc031 // xorl %eax, %eax + WORD $0xc931 // xorl %ecx, %ecx WORD $0xfe83; BYTE $0x0a // cmpl $10, %esi LONG $0xffc8830f; WORD $0xffff // jae LBB4_6, $-56(%rip) - LONG $0xffffd5e9; BYTE $0xff // jmp LBB4_7, $-43(%rip) + LONG $0xffffd4e9; BYTE $0xff // jmp LBB4_7, $-44(%rip) LBB4_8: LONG $0xfffe8148; WORD $0xf5e0; BYTE $0x05 // cmpq $99999999, %rsi - LONG $0x0005870f; WORD $0x0000 // ja LBB4_9, $5(%rip) - LONG $0x000029e9; BYTE $0x00 // jmp _u32toa_medium, $41(%rip) - -LBB4_9: - QUAD $0x86f26fc0ffffb848; WORD $0x0023 // movabsq $9999999999999999, %rax - WORD $0x3948; BYTE $0xc6 // cmpq %rax, %rsi - LONG $0x0005870f; WORD $0x0000 // ja LBB4_10, $5(%rip) - LONG $0x000161e9; BYTE $0x00 // jmp _u64toa_large_sse2, $353(%rip) - -LBB4_10: - LONG $0x0002cce9; BYTE $0x00 // jmp _u64toa_xlarge_sse2, $716(%rip) - QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90 - -_u32toa_medium: - BYTE $0x55 // pushq %rbp - WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + LONG $0x011e870f; WORD $0x0000 // ja LBB4_16, $286(%rip) WORD $0xf089 // movl %esi, %eax - LONG $0xb71759b9; BYTE $0xd1 // movl $3518437209, %ecx - LONG $0xc8af0f48 // imulq %rax, %rcx - LONG $0x2de9c148 // shrq $45, %rcx - LONG $0x2710d169; WORD $0x0000 // imull $10000, %ecx, %edx - WORD $0x8941; BYTE $0xf0 // movl %esi, %r8d - WORD $0x2941; BYTE $0xd0 // subl %edx, %r8d - LONG $0x83d06948; WORD $0x1bde; BYTE $0x43 // imulq $1125899907, %rax, %rdx - LONG $0x31eac148 // shrq $49, %rdx - WORD $0xe283; BYTE $0xfe // andl $-2, %edx - LONG $0x1fc16948; WORD $0xeb85; BYTE $0x51 // imulq $1374389535, %rcx, %rax - LONG $0x25e8c148 // shrq $37, %rax + LONG $0xb71759ba; BYTE $0xd1 // movl $3518437209, %edx + LONG $0xd0af0f48 // imulq %rax, %rdx + LONG $0x2deac148 // shrq $45, %rdx + LONG $0x10c26944; WORD $0x0027; BYTE $0x00 // imull $10000, %edx, %r8d + WORD $0xf189 // movl %esi, %ecx + WORD $0x2944; BYTE $0xc1 // subl %r8d, %ecx + LONG $0x83d0694c; WORD $0x1bde; BYTE $0x43 // imulq $1125899907, %rax, %r10 + LONG $0x31eac149 // shrq $49, %r10 + LONG $0xfee28341 // andl $-2, %r10d + WORD $0xb70f; BYTE $0xc2 // movzwl %dx, %eax + WORD $0xe8c1; BYTE $0x02 // shrl $2, %eax + LONG $0x147bc069; WORD $0x0000 // imull $5243, %eax, %eax + WORD $0xe8c1; BYTE $0x11 // shrl $17, %eax + WORD $0xc06b; BYTE $0x64 // imull $100, %eax, %eax + WORD $0xc229 // subl %eax, %edx + LONG $0xcab70f44 // movzwl %dx, %r9d + WORD $0x014d; BYTE $0xc9 // addq %r9, %r9 + WORD $0xb70f; BYTE $0xc1 // movzwl %cx, %eax + WORD $0xe8c1; BYTE $0x02 // shrl $2, %eax + LONG $0x147bc069; WORD $0x0000 // imull $5243, %eax, %eax + WORD $0xe8c1; BYTE $0x11 // shrl $17, %eax + LONG $0x00048d4c // leaq (%rax,%rax), %r8 WORD $0xc06b; BYTE $0x64 // imull $100, %eax, %eax WORD $0xc129 // subl %eax, %ecx - WORD $0x0148; BYTE $0xc9 // addq %rcx, %rcx + LONG $0xd9b70f44 // movzwl %cx, %r11d + WORD $0x014d; BYTE $0xdb // addq %r11, %r11 LONG $0x9680fe81; WORD $0x0098 // cmpl $10000000, %esi - LONG $0x0017820f; WORD $0x0000 // jb LBB5_2, $23(%rip) - LONG $0xdd058d48; WORD $0x00a3; BYTE $0x00 // leaq $41949(%rip), %rax /* _Digits(%rip) */ - LONG $0x0204b60f // movzbl (%rdx,%rax), %eax + LONG $0x0017820f; WORD $0x0000 // jb LBB4_11, $23(%rip) + LONG $0xb9058d48; WORD $0x00ae; BYTE $0x00 // leaq $44729(%rip), %rax /* _Digits(%rip) */ + LONG $0x02048a41 // movb (%r10,%rax), %al WORD $0x0788 // movb %al, (%rdi) - LONG $0x000001b8; BYTE $0x00 // movl $1, %eax - LONG $0x00000ee9; BYTE $0x00 // jmp LBB5_3, $14(%rip) + LONG $0x000001b9; BYTE $0x00 // movl $1, %ecx + LONG $0x00000ee9; BYTE $0x00 // jmp LBB4_12, $14(%rip) -LBB5_2: - WORD $0xc031 // xorl %eax, %eax +LBB4_11: + WORD $0xc931 // xorl %ecx, %ecx LONG $0x4240fe81; WORD $0x000f // cmpl $1000000, %esi - LONG $0x0074820f; WORD $0x0000 // jb LBB5_4, $116(%rip) - -LBB5_3: - WORD $0xd289 // movl %edx, %edx - LONG $0x01ca8348 // orq $1, %rdx - LONG $0xb2358d48; WORD $0x00a3; BYTE $0x00 // leaq $41906(%rip), %rsi /* _Digits(%rip) */ - LONG $0x3214b60f // movzbl (%rdx,%rsi), %edx - WORD $0xc689 // movl %eax, %esi - WORD $0xc0ff // incl %eax - WORD $0x1488; BYTE $0x37 // movb %dl, (%rdi,%rsi) + LONG $0x0076820f; WORD $0x0000 // jb LBB4_13, $118(%rip) -LBB5_5: - LONG $0xa0158d48; WORD $0x00a3; BYTE $0x00 // leaq $41888(%rip), %rdx /* _Digits(%rip) */ - LONG $0x1114b60f // movzbl (%rcx,%rdx), %edx - WORD $0xc689 // movl %eax, %esi - WORD $0xc0ff // incl %eax - WORD $0x1488; BYTE $0x37 // movb %dl, (%rdi,%rsi) +LBB4_12: + WORD $0x8944; BYTE $0xd0 // movl %r10d, %eax + LONG $0x01c88348 // orq $1, %rax + LONG $0x8d358d48; WORD $0x00ae; BYTE $0x00 // leaq $44685(%rip), %rsi /* _Digits(%rip) */ + WORD $0x048a; BYTE $0x30 // movb (%rax,%rsi), %al + WORD $0xce89 // movl %ecx, %esi + WORD $0xc1ff // incl %ecx + WORD $0x0488; BYTE $0x37 // movb %al, (%rdi,%rsi) -LBB5_6: - LONG $0xd0b70f41 // movzwl %r8w, %edx - WORD $0xeac1; BYTE $0x02 // shrl $2, %edx - LONG $0x147bd269; WORD $0x0000 // imull $5243, %edx, %edx - WORD $0xeac1; BYTE $0x11 // shrl $17, %edx - WORD $0xf26b; BYTE $0x64 // imull $100, %edx, %esi - WORD $0x2941; BYTE $0xf0 // subl %esi, %r8d - LONG $0xc0b70f45 // movzwl %r8w, %r8d - WORD $0xc989 // movl %ecx, %ecx - LONG $0x01c98348 // orq $1, %rcx - LONG $0x6e0d8d4c; WORD $0x00a3; BYTE $0x00 // leaq $41838(%rip), %r9 /* _Digits(%rip) */ - LONG $0x0cb60f42; BYTE $0x09 // movzbl (%rcx,%r9), %ecx - WORD $0xc689 // movl %eax, %esi - WORD $0x0c88; BYTE $0x37 // movb %cl, (%rdi,%rsi) - LONG $0x0cb70f41; BYTE $0x51 // movzwl (%r9,%rdx,2), %ecx - LONG $0x374c8966; BYTE $0x01 // movw %cx, $1(%rdi,%rsi) - LONG $0x0cb70f43; BYTE $0x41 // movzwl (%r9,%r8,2), %ecx - LONG $0x374c8966; BYTE $0x03 // movw %cx, $3(%rdi,%rsi) - WORD $0xc083; BYTE $0x05 // addl $5, %eax +LBB4_14: + LONG $0x7c058d48; WORD $0x00ae; BYTE $0x00 // leaq $44668(%rip), %rax /* _Digits(%rip) */ + LONG $0x01048a41 // movb (%r9,%rax), %al + WORD $0xce89 // movl %ecx, %esi + WORD $0xc1ff // incl %ecx + WORD $0x0488; BYTE $0x37 // movb %al, (%rdi,%rsi) + +LBB4_15: + LONG $0xc1b70f41 // movzwl %r9w, %eax + LONG $0x01c88348 // orq $1, %rax + LONG $0x62358d48; WORD $0x00ae; BYTE $0x00 // leaq $44642(%rip), %rsi /* _Digits(%rip) */ + WORD $0x048a; BYTE $0x30 // movb (%rax,%rsi), %al + WORD $0xca89 // movl %ecx, %edx + WORD $0x0488; BYTE $0x17 // movb %al, (%rdi,%rdx) + LONG $0x30048a41 // movb (%r8,%rsi), %al + LONG $0x01174488 // movb %al, $1(%rdi,%rdx) + LONG $0xc0b70f41 // movzwl %r8w, %eax + LONG $0x01c88348 // orq $1, %rax + WORD $0x048a; BYTE $0x30 // movb (%rax,%rsi), %al + LONG $0x02174488 // movb %al, $2(%rdi,%rdx) + LONG $0x33048a41 // movb (%r11,%rsi), %al + LONG $0x03174488 // movb %al, $3(%rdi,%rdx) + LONG $0xc3b70f41 // movzwl %r11w, %eax + LONG $0x01c88348 // orq $1, %rax + WORD $0x048a; BYTE $0x30 // movb (%rax,%rsi), %al + WORD $0xc183; BYTE $0x05 // addl $5, %ecx + LONG $0x04174488 // movb %al, $4(%rdi,%rdx) + WORD $0xc889 // movl %ecx, %eax BYTE $0x5d // popq %rbp BYTE $0xc3 // retq -LBB5_4: - WORD $0xc031 // xorl %eax, %eax +LBB4_13: + WORD $0xc931 // xorl %ecx, %ecx LONG $0x86a0fe81; WORD $0x0001 // cmpl $100000, %esi - LONG $0xff96830f; WORD $0xffff // jae LBB5_5, $-106(%rip) - LONG $0xffffa3e9; BYTE $0xff // jmp LBB5_6, $-93(%rip) - QUAD $0x0000000000000000 // .p2align 4, 0x00 - -LCPI6_0: - QUAD $0x00000000d1b71759 // .quad 3518437209 - QUAD $0x00000000d1b71759 // .quad 3518437209 + LONG $0xff94830f; WORD $0xffff // jae LBB4_14, $-108(%rip) + LONG $0xffffa1e9; BYTE $0xff // jmp LBB4_15, $-95(%rip) -LCPI6_1: - WORD $0x20c5 // .word 8389 - WORD $0x147b // .word 5243 - WORD $0x3334 // .word 13108 - WORD $0x8000 // .word 32768 - WORD $0x20c5 // .word 8389 - WORD $0x147b // .word 5243 - WORD $0x3334 // .word 13108 - WORD $0x8000 // .word 32768 - -LCPI6_2: - WORD $0x0080 // .word 128 - WORD $0x0800 // .word 2048 - WORD $0x2000 // .word 8192 - WORD $0x8000 // .word 32768 - WORD $0x0080 // .word 128 - WORD $0x0800 // .word 2048 - WORD $0x2000 // .word 8192 - WORD $0x8000 // .word 32768 - -LCPI6_3: - WORD $0x000a // .word 10 - WORD $0x000a // .word 10 - WORD $0x000a // .word 10 - WORD $0x000a // .word 10 - WORD $0x000a // .word 10 - WORD $0x000a // .word 10 - WORD $0x000a // .word 10 - WORD $0x000a // .word 10 - -LCPI6_4: - QUAD $0x3030303030303030; QUAD $0x3030303030303030 // .space 16, '0000000000000000' - - // .p2align 4, 0x90 -_u64toa_large_sse2: - BYTE $0x55 // pushq %rbp - WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp +LBB4_16: + QUAD $0x86f26fc0ffffb848; WORD $0x0023 // movabsq $9999999999999999, %rax + WORD $0x3948; BYTE $0xc6 // cmpq %rax, %rsi + LONG $0x0115870f; WORD $0x0000 // ja LBB4_18, $277(%rip) QUAD $0x77118461cefdb948; WORD $0xabcc // movabsq $-6067343680855748867, %rcx WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax WORD $0xf748; BYTE $0xe1 // mulq %rcx @@ -1343,7 +1122,7 @@ _u64toa_large_sse2: LONG $0xe100c269; WORD $0x05f5 // imull $100000000, %edx, %eax WORD $0xc629 // subl %eax, %esi LONG $0xc26e0f66 // movd %edx, %xmm0 - QUAD $0xffffff840d6f0f66 // movdqa $-124(%rip), %xmm1 /* LCPI6_0(%rip) */ + QUAD $0xfffffd970d6f0f66 // movdqa $-617(%rip), %xmm1 /* LCPI4_0(%rip) */ LONG $0xd06f0f66 // movdqa %xmm0, %xmm2 LONG $0xd1f40f66 // pmuludq %xmm1, %xmm2 LONG $0xd2730f66; BYTE $0x2d // psrlq $45, %xmm2 @@ -1356,11 +1135,11 @@ _u64toa_large_sse2: LONG $0xf2730f66; BYTE $0x02 // psllq $2, %xmm2 LONG $0xc2700ff2; BYTE $0x50 // pshuflw $80, %xmm2, %xmm0 LONG $0xc0700f66; BYTE $0x50 // pshufd $80, %xmm0, %xmm0 - QUAD $0xffffff56156f0f66 // movdqa $-170(%rip), %xmm2 /* LCPI6_1(%rip) */ + QUAD $0xfffffd69156f0f66 // movdqa $-663(%rip), %xmm2 /* LCPI4_1(%rip) */ LONG $0xc2e40f66 // pmulhuw %xmm2, %xmm0 - QUAD $0xffffff5a256f0f66 // movdqa $-166(%rip), %xmm4 /* LCPI6_2(%rip) */ + QUAD $0xfffffd6d256f0f66 // movdqa $-659(%rip), %xmm4 /* LCPI4_2(%rip) */ LONG $0xc4e40f66 // pmulhuw %xmm4, %xmm0 - QUAD $0xffffff5e2d6f0f66 // movdqa $-162(%rip), %xmm5 /* LCPI6_3(%rip) */ + QUAD $0xfffffd712d6f0f66 // movdqa $-655(%rip), %xmm5 /* LCPI4_3(%rip) */ LONG $0xf06f0f66 // movdqa %xmm0, %xmm6 LONG $0xf5d50f66 // pmullw %xmm5, %xmm6 LONG $0xf6730f66; BYTE $0x10 // psllq $16, %xmm6 @@ -1380,65 +1159,25 @@ _u64toa_large_sse2: LONG $0xf5730f66; BYTE $0x10 // psllq $16, %xmm5 LONG $0xcdf90f66 // psubw %xmm5, %xmm1 LONG $0xc1670f66 // packuswb %xmm1, %xmm0 - QUAD $0xffffff140d6f0f66 // movdqa $-236(%rip), %xmm1 /* LCPI6_4(%rip) */ + QUAD $0xfffffd270d6f0f66 // movdqa $-729(%rip), %xmm1 /* LCPI4_4(%rip) */ LONG $0xc8fc0f66 // paddb %xmm0, %xmm1 LONG $0xd2ef0f66 // pxor %xmm2, %xmm2 LONG $0xd0740f66 // pcmpeqb %xmm0, %xmm2 LONG $0xc2d70f66 // pmovmskb %xmm2, %eax - WORD $0xd0f7 // notl %eax LONG $0x0080000d; BYTE $0x00 // orl $32768, %eax - WORD $0xbc0f; BYTE $0xc8 // bsfl %eax, %ecx - LONG $0x000010b8; BYTE $0x00 // movl $16, %eax - WORD $0xc829 // subl %ecx, %eax - LONG $0x04e1c148 // shlq $4, %rcx - LONG $0x38158d48; WORD $0x00c9; BYTE $0x00 // leaq $51512(%rip), %rdx /* _VecShiftShuffles(%rip) */ - LONG $0x00380f66; WORD $0x110c // pshufb (%rcx,%rdx), %xmm1 + LONG $0xff7fff35; BYTE $0xff // xorl $-32769, %eax + WORD $0xbc0f; BYTE $0xc0 // bsfl %eax, %eax + LONG $0x000010b9; BYTE $0x00 // movl $16, %ecx + WORD $0xc129 // subl %eax, %ecx + LONG $0x04e0c148 // shlq $4, %rax + LONG $0x58158d48; WORD $0x00d4; BYTE $0x00 // leaq $54360(%rip), %rdx /* _VecShiftShuffles(%rip) */ + LONG $0x00380f66; WORD $0x100c // pshufb (%rax,%rdx), %xmm1 LONG $0x0f7f0ff3 // movdqu %xmm1, (%rdi) + WORD $0xc889 // movl %ecx, %eax BYTE $0x5d // popq %rbp BYTE $0xc3 // retq - QUAD $0x0000000000000000; LONG $0x00000000 // .p2align 4, 0x00 - -LCPI7_0: - QUAD $0x00000000d1b71759 // .quad 3518437209 - QUAD $0x00000000d1b71759 // .quad 3518437209 - -LCPI7_1: - WORD $0x20c5 // .word 8389 - WORD $0x147b // .word 5243 - WORD $0x3334 // .word 13108 - WORD $0x8000 // .word 32768 - WORD $0x20c5 // .word 8389 - WORD $0x147b // .word 5243 - WORD $0x3334 // .word 13108 - WORD $0x8000 // .word 32768 -LCPI7_2: - WORD $0x0080 // .word 128 - WORD $0x0800 // .word 2048 - WORD $0x2000 // .word 8192 - WORD $0x8000 // .word 32768 - WORD $0x0080 // .word 128 - WORD $0x0800 // .word 2048 - WORD $0x2000 // .word 8192 - WORD $0x8000 // .word 32768 - -LCPI7_3: - WORD $0x000a // .word 10 - WORD $0x000a // .word 10 - WORD $0x000a // .word 10 - WORD $0x000a // .word 10 - WORD $0x000a // .word 10 - WORD $0x000a // .word 10 - WORD $0x000a // .word 10 - WORD $0x000a // .word 10 - -LCPI7_4: - QUAD $0x3030303030303030; QUAD $0x3030303030303030 // .space 16, '0000000000000000' - - // .p2align 4, 0x90 -_u64toa_xlarge_sse2: - BYTE $0x55 // pushq %rbp - WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp +LBB4_18: QUAD $0x652fb1137857b948; WORD $0x39a5 // movabsq $4153837486827862103, %rcx WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax WORD $0xf748; BYTE $0xe1 // mulq %rcx @@ -1447,29 +1186,31 @@ _u64toa_xlarge_sse2: LONG $0xc2af0f48 // imulq %rdx, %rax WORD $0x2948; BYTE $0xc6 // subq %rax, %rsi WORD $0xfa83; BYTE $0x09 // cmpl $9, %edx - LONG $0x000f870f; WORD $0x0000 // ja LBB7_2, $15(%rip) + LONG $0x000f870f; WORD $0x0000 // ja LBB4_20, $15(%rip) WORD $0xc280; BYTE $0x30 // addb $48, %dl WORD $0x1788 // movb %dl, (%rdi) LONG $0x000001b9; BYTE $0x00 // movl $1, %ecx - LONG $0x0000a7e9; BYTE $0x00 // jmp LBB7_7, $167(%rip) + LONG $0x0000bae9; BYTE $0x00 // jmp LBB4_25, $186(%rip) -LBB7_2: +LBB4_20: WORD $0xfa83; BYTE $0x63 // cmpl $99, %edx - LONG $0x001a870f; WORD $0x0000 // ja LBB7_4, $26(%rip) + LONG $0x001f870f; WORD $0x0000 // ja LBB4_22, $31(%rip) WORD $0xd089 // movl %edx, %eax - LONG $0x1d0d8d48; WORD $0x00a1; BYTE $0x00 // leaq $41245(%rip), %rcx /* _Digits(%rip) */ - LONG $0x4104b70f // movzwl (%rcx,%rax,2), %eax - WORD $0x8966; BYTE $0x07 // movw %ax, (%rdi) + LONG $0x9b0d8d48; WORD $0x00ac; BYTE $0x00 // leaq $44187(%rip), %rcx /* _Digits(%rip) */ + WORD $0x148a; BYTE $0x41 // movb (%rcx,%rax,2), %dl + LONG $0x0141448a // movb $1(%rcx,%rax,2), %al + WORD $0x1788 // movb %dl, (%rdi) + WORD $0x4788; BYTE $0x01 // movb %al, $1(%rdi) LONG $0x000002b9; BYTE $0x00 // movl $2, %ecx - LONG $0x000084e9; BYTE $0x00 // jmp LBB7_7, $132(%rip) + LONG $0x000092e9; BYTE $0x00 // jmp LBB4_25, $146(%rip) -LBB7_4: +LBB4_22: WORD $0xd089 // movl %edx, %eax WORD $0xe8c1; BYTE $0x02 // shrl $2, %eax LONG $0x147bc069; WORD $0x0000 // imull $5243, %eax, %eax WORD $0xe8c1; BYTE $0x11 // shrl $17, %eax LONG $0x03e7fa81; WORD $0x0000 // cmpl $999, %edx - LONG $0x0037870f; WORD $0x0000 // ja LBB7_6, $55(%rip) + LONG $0x003c870f; WORD $0x0000 // ja LBB4_24, $60(%rip) WORD $0xc083; BYTE $0x30 // addl $48, %eax WORD $0x0788 // movb %al, (%rdi) WORD $0xb70f; BYTE $0xc2 // movzwl %dx, %eax @@ -1480,91 +1221,96 @@ LBB7_4: WORD $0xc96b; BYTE $0x64 // imull $100, %ecx, %ecx WORD $0xc829 // subl %ecx, %eax WORD $0xb70f; BYTE $0xc0 // movzwl %ax, %eax - LONG $0xcd0d8d48; WORD $0x00a0; BYTE $0x00 // leaq $41165(%rip), %rcx /* _Digits(%rip) */ - LONG $0x4104b70f // movzwl (%rcx,%rax,2), %eax - LONG $0x01478966 // movw %ax, $1(%rdi) + LONG $0x460d8d48; WORD $0x00ac; BYTE $0x00 // leaq $44102(%rip), %rcx /* _Digits(%rip) */ + WORD $0x148a; BYTE $0x41 // movb (%rcx,%rax,2), %dl + LONG $0x0141448a // movb $1(%rcx,%rax,2), %al + WORD $0x5788; BYTE $0x01 // movb %dl, $1(%rdi) + WORD $0x4788; BYTE $0x02 // movb %al, $2(%rdi) LONG $0x000003b9; BYTE $0x00 // movl $3, %ecx - LONG $0x000033e9; BYTE $0x00 // jmp LBB7_7, $51(%rip) + LONG $0x00003ce9; BYTE $0x00 // jmp LBB4_25, $60(%rip) -LBB7_6: +LBB4_24: WORD $0xc86b; BYTE $0x64 // imull $100, %eax, %ecx WORD $0xca29 // subl %ecx, %edx WORD $0xb70f; BYTE $0xc0 // movzwl %ax, %eax - LONG $0xac0d8d48; WORD $0x00a0; BYTE $0x00 // leaq $41132(%rip), %rcx /* _Digits(%rip) */ - LONG $0x4104b70f // movzwl (%rcx,%rax,2), %eax - WORD $0x8966; BYTE $0x07 // movw %ax, (%rdi) + LONG $0x20058d4c; WORD $0x00ac; BYTE $0x00 // leaq $44064(%rip), %r8 /* _Digits(%rip) */ + LONG $0x400c8a41 // movb (%r8,%rax,2), %cl + LONG $0x40448a41; BYTE $0x01 // movb $1(%r8,%rax,2), %al + WORD $0x0f88 // movb %cl, (%rdi) + WORD $0x4788; BYTE $0x01 // movb %al, $1(%rdi) WORD $0xb70f; BYTE $0xc2 // movzwl %dx, %eax - LONG $0x4114b60f // movzbl (%rcx,%rax,2), %edx + LONG $0x400c8a41 // movb (%r8,%rax,2), %cl WORD $0x0148; BYTE $0xc0 // addq %rax, %rax - WORD $0x5788; BYTE $0x02 // movb %dl, $2(%rdi) + WORD $0x4f88; BYTE $0x02 // movb %cl, $2(%rdi) + WORD $0xc883; BYTE $0x01 // orl $1, %eax WORD $0xb70f; BYTE $0xc0 // movzwl %ax, %eax - LONG $0x0844b60f; BYTE $0x01 // movzbl $1(%rax,%rcx), %eax + LONG $0x00048a42 // movb (%rax,%r8), %al WORD $0x4788; BYTE $0x03 // movb %al, $3(%rdi) LONG $0x000004b9; BYTE $0x00 // movl $4, %ecx -LBB7_7: - QUAD $0x77118461cefdba48; WORD $0xabcc // movabsq $-6067343680855748867, %rdx - WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax - WORD $0xf748; BYTE $0xe2 // mulq %rdx - LONG $0x1aeac148 // shrq $26, %rdx - LONG $0xc26e0f66 // movd %edx, %xmm0 - QUAD $0xfffffea80d6f0f66 // movdqa $-344(%rip), %xmm1 /* LCPI7_0(%rip) */ - LONG $0xd86f0f66 // movdqa %xmm0, %xmm3 - LONG $0xd9f40f66 // pmuludq %xmm1, %xmm3 - LONG $0xd3730f66; BYTE $0x2d // psrlq $45, %xmm3 - LONG $0x002710b8; BYTE $0x00 // movl $10000, %eax - LONG $0x6e0f4866; BYTE $0xd0 // movq %rax, %xmm2 - LONG $0xe36f0f66 // movdqa %xmm3, %xmm4 - LONG $0xe2f40f66 // pmuludq %xmm2, %xmm4 - LONG $0xc4fa0f66 // psubd %xmm4, %xmm0 - LONG $0xd8610f66 // punpcklwd %xmm0, %xmm3 - LONG $0xf3730f66; BYTE $0x02 // psllq $2, %xmm3 - LONG $0xc3700ff2; BYTE $0x50 // pshuflw $80, %xmm3, %xmm0 - LONG $0xc0700f66; BYTE $0x50 // pshufd $80, %xmm0, %xmm0 - QUAD $0xfffffe7a256f0f66 // movdqa $-390(%rip), %xmm4 /* LCPI7_1(%rip) */ - LONG $0xc4e40f66 // pmulhuw %xmm4, %xmm0 - QUAD $0xfffffe7e2d6f0f66 // movdqa $-386(%rip), %xmm5 /* LCPI7_2(%rip) */ - LONG $0xc5e40f66 // pmulhuw %xmm5, %xmm0 - QUAD $0xfffffe821d6f0f66 // movdqa $-382(%rip), %xmm3 /* LCPI7_3(%rip) */ - LONG $0xf06f0f66 // movdqa %xmm0, %xmm6 - LONG $0xf3d50f66 // pmullw %xmm3, %xmm6 - LONG $0xf6730f66; BYTE $0x10 // psllq $16, %xmm6 - LONG $0xc6f90f66 // psubw %xmm6, %xmm0 - LONG $0xe100c269; WORD $0x05f5 // imull $100000000, %edx, %eax - WORD $0xc629 // subl %eax, %esi - LONG $0xf66e0f66 // movd %esi, %xmm6 - LONG $0xcef40f66 // pmuludq %xmm6, %xmm1 - LONG $0xd1730f66; BYTE $0x2d // psrlq $45, %xmm1 - LONG $0xd1f40f66 // pmuludq %xmm1, %xmm2 - LONG $0xf2fa0f66 // psubd %xmm2, %xmm6 - LONG $0xce610f66 // punpcklwd %xmm6, %xmm1 - LONG $0xf1730f66; BYTE $0x02 // psllq $2, %xmm1 - LONG $0xc9700ff2; BYTE $0x50 // pshuflw $80, %xmm1, %xmm1 - LONG $0xc9700f66; BYTE $0x50 // pshufd $80, %xmm1, %xmm1 - LONG $0xcce40f66 // pmulhuw %xmm4, %xmm1 - LONG $0xcde40f66 // pmulhuw %xmm5, %xmm1 - LONG $0xd9d50f66 // pmullw %xmm1, %xmm3 - LONG $0xf3730f66; BYTE $0x10 // psllq $16, %xmm3 - LONG $0xcbf90f66 // psubw %xmm3, %xmm1 - LONG $0xc1670f66 // packuswb %xmm1, %xmm0 - QUAD $0xfffffe3005fc0f66 // paddb $-464(%rip), %xmm0 /* LCPI7_4(%rip) */ - WORD $0xc889 // movl %ecx, %eax - LONG $0x047f0ff3; BYTE $0x07 // movdqu %xmm0, (%rdi,%rax) - WORD $0xc983; BYTE $0x10 // orl $16, %ecx - WORD $0xc889 // movl %ecx, %eax - BYTE $0x5d // popq %rbp - BYTE $0xc3 // retq - WORD $0x0000 // .p2align 4, 0x00 +LBB4_25: + QUAD $0x77118461cefdba48; WORD $0xabcc // movabsq $-6067343680855748867, %rdx + WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax + WORD $0xf748; BYTE $0xe2 // mulq %rdx + LONG $0x1aeac148 // shrq $26, %rdx + LONG $0xc26e0f66 // movd %edx, %xmm0 + QUAD $0xfffffb930d6f0f66 // movdqa $-1133(%rip), %xmm1 /* LCPI4_0(%rip) */ + LONG $0xd86f0f66 // movdqa %xmm0, %xmm3 + LONG $0xd9f40f66 // pmuludq %xmm1, %xmm3 + LONG $0xd3730f66; BYTE $0x2d // psrlq $45, %xmm3 + LONG $0x002710b8; BYTE $0x00 // movl $10000, %eax + LONG $0x6e0f4866; BYTE $0xd0 // movq %rax, %xmm2 + LONG $0xe36f0f66 // movdqa %xmm3, %xmm4 + LONG $0xe2f40f66 // pmuludq %xmm2, %xmm4 + LONG $0xc4fa0f66 // psubd %xmm4, %xmm0 + LONG $0xd8610f66 // punpcklwd %xmm0, %xmm3 + LONG $0xf3730f66; BYTE $0x02 // psllq $2, %xmm3 + LONG $0xc3700ff2; BYTE $0x50 // pshuflw $80, %xmm3, %xmm0 + LONG $0xc0700f66; BYTE $0x50 // pshufd $80, %xmm0, %xmm0 + QUAD $0xfffffb65256f0f66 // movdqa $-1179(%rip), %xmm4 /* LCPI4_1(%rip) */ + LONG $0xc4e40f66 // pmulhuw %xmm4, %xmm0 + QUAD $0xfffffb692d6f0f66 // movdqa $-1175(%rip), %xmm5 /* LCPI4_2(%rip) */ + LONG $0xc5e40f66 // pmulhuw %xmm5, %xmm0 + QUAD $0xfffffb6d1d6f0f66 // movdqa $-1171(%rip), %xmm3 /* LCPI4_3(%rip) */ + LONG $0xf06f0f66 // movdqa %xmm0, %xmm6 + LONG $0xf3d50f66 // pmullw %xmm3, %xmm6 + LONG $0xf6730f66; BYTE $0x10 // psllq $16, %xmm6 + LONG $0xc6f90f66 // psubw %xmm6, %xmm0 + LONG $0xe100c269; WORD $0x05f5 // imull $100000000, %edx, %eax + WORD $0xc629 // subl %eax, %esi + LONG $0xf66e0f66 // movd %esi, %xmm6 + LONG $0xcef40f66 // pmuludq %xmm6, %xmm1 + LONG $0xd1730f66; BYTE $0x2d // psrlq $45, %xmm1 + LONG $0xd1f40f66 // pmuludq %xmm1, %xmm2 + LONG $0xf2fa0f66 // psubd %xmm2, %xmm6 + LONG $0xce610f66 // punpcklwd %xmm6, %xmm1 + LONG $0xf1730f66; BYTE $0x02 // psllq $2, %xmm1 + LONG $0xc9700ff2; BYTE $0x50 // pshuflw $80, %xmm1, %xmm1 + LONG $0xc9700f66; BYTE $0x50 // pshufd $80, %xmm1, %xmm1 + LONG $0xcce40f66 // pmulhuw %xmm4, %xmm1 + LONG $0xcde40f66 // pmulhuw %xmm5, %xmm1 + LONG $0xd9d50f66 // pmullw %xmm1, %xmm3 + LONG $0xf3730f66; BYTE $0x10 // psllq $16, %xmm3 + LONG $0xcbf90f66 // psubw %xmm3, %xmm1 + LONG $0xc1670f66 // packuswb %xmm1, %xmm0 + QUAD $0xfffffb1b05fc0f66 // paddb $-1253(%rip), %xmm0 /* LCPI4_4(%rip) */ + WORD $0xc889 // movl %ecx, %eax + LONG $0x047f0ff3; BYTE $0x07 // movdqu %xmm0, (%rdi,%rax) + WORD $0xc983; BYTE $0x10 // orl $16, %ecx + WORD $0xc889 // movl %ecx, %eax + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + QUAD $0x0000000000000000; LONG $0x00000000; BYTE $0x00 // .p2align 4, 0x00 + +LCPI5_0: + QUAD $0x2020202020202020; QUAD $0x2020202020202020 // .space 16, ' ' -LCPI8_0: +LCPI5_1: QUAD $0x2222222222222222; QUAD $0x2222222222222222 // .space 16, '""""""""""""""""' -LCPI8_1: +LCPI5_2: QUAD $0x5c5c5c5c5c5c5c5c; QUAD $0x5c5c5c5c5c5c5c5c // .space 16, '\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' -LCPI8_2: - QUAD $0x1f1f1f1f1f1f1f1f; QUAD $0x1f1f1f1f1f1f1f1f // .space 16, '\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f' - // .p2align 4, 0x90 _quote: BYTE $0x55 // pushq %rbp @@ -1574,504 +1320,523 @@ _quote: WORD $0x5541 // pushq %r13 WORD $0x5441 // pushq %r12 BYTE $0x53 // pushq %rbx - LONG $0x20ec8348 // subq $32, %rsp - WORD $0x8949; BYTE $0xcb // movq %rcx, %r11 + LONG $0x10ec8348 // subq $16, %rsp + WORD $0x8949; BYTE $0xcd // movq %rcx, %r13 WORD $0x8949; BYTE $0xd7 // movq %rdx, %r15 - WORD $0x8b4c; BYTE $0x11 // movq (%rcx), %r10 - LONG $0x01c0f641 // testb $1, %r8b WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax - LONG $0x380d8d48; WORD $0x00c7; BYTE $0x00 // leaq $51000(%rip), %rcx /* __SingleQuoteTab(%rip) */ - LONG $0x31258d4c; WORD $0x00d7; BYTE $0x00 // leaq $55089(%rip), %r12 /* __DoubleQuoteTab(%rip) */ - LONG $0xe1440f4c // cmoveq %rcx, %r12 + WORD $0x8b4c; BYTE $0x19 // movq (%rcx), %r11 + LONG $0x01c0f641 // testb $1, %r8b + LONG $0x980d8d48; WORD $0x00d2; BYTE $0x00 // leaq $53912(%rip), %rcx /* __SingleQuoteTab(%rip) */ + LONG $0x91058d4c; WORD $0x00e2; BYTE $0x00 // leaq $58001(%rip), %r8 /* __DoubleQuoteTab(%rip) */ + LONG $0xc1440f4c // cmoveq %rcx, %r8 QUAD $0x00000000f50c8d48 // leaq (,%rsi,8), %rcx - WORD $0x3949; BYTE $0xca // cmpq %rcx, %r10 - LONG $0x03fc8d0f; WORD $0x0000 // jge LBB8_56, $1020(%rip) + WORD $0x3949; BYTE $0xcb // cmpq %rcx, %r11 + LONG $0x044f8d0f; WORD $0x0000 // jge LBB5_51, $1103(%rip) WORD $0x894d; BYTE $0xfe // movq %r15, %r14 - WORD $0x8949; BYTE $0xf9 // movq %rdi, %r9 + WORD $0x8949; BYTE $0xfa // movq %rdi, %r10 WORD $0x8548; BYTE $0xc0 // testq %rax, %rax - LONG $0x03dc840f; WORD $0x0000 // je LBB8_79, $988(%rip) - LONG $0xc85d894c // movq %r11, $-56(%rbp) - QUAD $0xffffff71056f0f66 // movdqa $-143(%rip), %xmm0 /* LCPI8_0(%rip) */ - QUAD $0xffffff790d6f0f66 // movdqa $-135(%rip), %xmm1 /* LCPI8_1(%rip) */ - QUAD $0xffffff81156f0f66 // movdqa $-127(%rip), %xmm2 /* LCPI8_2(%rip) */ - WORD $0x8948; BYTE $0xf9 // movq %rdi, %rcx - LONG $0xd07d894c // movq %r15, $-48(%rbp) + LONG $0x0431840f; WORD $0x0000 // je LBB5_74, $1073(%rip) + QUAD $0xffffff75056f0f66 // movdqa $-139(%rip), %xmm0 /* LCPI5_0(%rip) */ + QUAD $0xffffff7d0d6f0f66 // movdqa $-131(%rip), %xmm1 /* LCPI5_1(%rip) */ + QUAD $0xffffff85156f0f66 // movdqa $-123(%rip), %xmm2 /* LCPI5_2(%rip) */ + LONG $0xdb760f66 // pcmpeqd %xmm3, %xmm3 + WORD $0x8949; BYTE $0xfa // movq %rdi, %r10 WORD $0x894d; BYTE $0xfe // movq %r15, %r14 - LONG $0xc065894c // movq %r12, $-64(%rbp) + LONG $0xc87d894c // movq %r15, $-56(%rbp) -LBB8_3: - WORD $0x8949; BYTE $0xc9 // movq %rcx, %r9 - LONG $0x10f88348 // cmpq $16, %rax - WORD $0x9d0f; BYTE $0xc3 // setge %bl - WORD $0x894d; BYTE $0xd4 // movq %r10, %r12 +LBB5_3: + LONG $0x0ff88348 // cmpq $15, %rax + WORD $0x9f0f; BYTE $0xc2 // setg %dl + WORD $0x894d; BYTE $0xd9 // movq %r11, %r9 WORD $0x894d; BYTE $0xf7 // movq %r14, %r15 - WORD $0x8949; BYTE $0xc3 // movq %rax, %r11 - WORD $0x8949; BYTE $0xcd // movq %rcx, %r13 - LONG $0x10fa8349 // cmpq $16, %r10 - LONG $0x007b8c0f; WORD $0x0000 // jl LBB8_10, $123(%rip) + WORD $0x8948; BYTE $0xc1 // movq %rax, %rcx + WORD $0x894d; BYTE $0xd4 // movq %r10, %r12 + LONG $0x10fb8349 // cmpq $16, %r11 + LONG $0x009a8c0f; WORD $0x0000 // jl LBB5_9, $154(%rip) LONG $0x10f88348 // cmpq $16, %rax - LONG $0x00718c0f; WORD $0x0000 // jl LBB8_10, $113(%rip) - WORD $0x3145; BYTE $0xff // xorl %r15d, %r15d + LONG $0x00908c0f; WORD $0x0000 // jl LBB5_9, $144(%rip) + WORD $0x894d; BYTE $0xd4 // movq %r10, %r12 WORD $0x8948; BYTE $0xc6 // movq %rax, %rsi - WORD $0x894c; BYTE $0xd2 // movq %r10, %rdx - - // .p2align 4, 0x90 -LBB8_6: - LONG $0x6f0f43f3; WORD $0x391c // movdqu (%r9,%r15), %xmm3 - LONG $0xe36f0f66 // movdqa %xmm3, %xmm4 - LONG $0x7f0f43f3; WORD $0x3e1c // movdqu %xmm3, (%r14,%r15) - LONG $0xeb6f0f66 // movdqa %xmm3, %xmm5 - LONG $0xeada0f66 // pminub %xmm2, %xmm5 - LONG $0xeb740f66 // pcmpeqb %xmm3, %xmm5 - LONG $0xd8740f66 // pcmpeqb %xmm0, %xmm3 - LONG $0xe1740f66 // pcmpeqb %xmm1, %xmm4 - LONG $0xe3eb0f66 // por %xmm3, %xmm4 - LONG $0xeceb0f66 // por %xmm4, %xmm5 - LONG $0xcdd70f66 // pmovmskb %xmm5, %ecx - WORD $0xc985 // testl %ecx, %ecx - LONG $0x0132850f; WORD $0x0000 // jne LBB8_23, $306(%rip) - LONG $0xf05e8d4c // leaq $-16(%rsi), %r11 - LONG $0xf0628d4c // leaq $-16(%rdx), %r12 - LONG $0x10c78349 // addq $16, %r15 - LONG $0x20fe8348 // cmpq $32, %rsi - WORD $0x9d0f; BYTE $0xc3 // setge %bl - LONG $0x00108c0f; WORD $0x0000 // jl LBB8_9, $16(%rip) - WORD $0x894c; BYTE $0xde // movq %r11, %rsi - LONG $0x1ffa8348 // cmpq $31, %rdx - WORD $0x894c; BYTE $0xe2 // movq %r12, %rdx - LONG $0xff9f8f0f; WORD $0xffff // jg LBB8_6, $-97(%rip) + WORD $0x894d; BYTE $0xf7 // movq %r14, %r15 + WORD $0x894c; BYTE $0xdb // movq %r11, %rbx + LONG $0x90909090 // .p2align 4, 0x90 -LBB8_9: - LONG $0x392c8d4f // leaq (%r9,%r15), %r13 - WORD $0x014d; BYTE $0xf7 // addq %r14, %r15 +LBB5_6: + LONG $0x6f0f41f3; WORD $0x2424 // movdqu (%r12), %xmm4 + LONG $0xe86f0f66 // movdqa %xmm0, %xmm5 + LONG $0xec640f66 // pcmpgtb %xmm4, %xmm5 + LONG $0xf46f0f66 // movdqa %xmm4, %xmm6 + LONG $0xf1740f66 // pcmpeqb %xmm1, %xmm6 + LONG $0xfc6f0f66 // movdqa %xmm4, %xmm7 + LONG $0xfa740f66 // pcmpeqb %xmm2, %xmm7 + LONG $0xfeeb0f66 // por %xmm6, %xmm7 + LONG $0x7f0f41f3; BYTE $0x27 // movdqu %xmm4, (%r15) + LONG $0xe3640f66 // pcmpgtb %xmm3, %xmm4 + LONG $0xe5db0f66 // pand %xmm5, %xmm4 + LONG $0xe7eb0f66 // por %xmm7, %xmm4 + LONG $0xccd70f66 // pmovmskb %xmm4, %ecx + WORD $0x8566; BYTE $0xc9 // testw %cx, %cx + LONG $0x012e850f; WORD $0x0000 // jne LBB5_18, $302(%rip) + LONG $0x10c48349 // addq $16, %r12 + LONG $0x10c78349 // addq $16, %r15 + LONG $0xf04e8d48 // leaq $-16(%rsi), %rcx + LONG $0xf04b8d4c // leaq $-16(%rbx), %r9 + LONG $0x1ffe8348 // cmpq $31, %rsi + WORD $0x9f0f; BYTE $0xc2 // setg %dl + LONG $0x20fe8348 // cmpq $32, %rsi + LONG $0x001f8c0f; WORD $0x0000 // jl LBB5_9, $31(%rip) + WORD $0x8948; BYTE $0xce // movq %rcx, %rsi + LONG $0x1ffb8348 // cmpq $31, %rbx + WORD $0x894c; BYTE $0xcb // movq %r9, %rbx + LONG $0xff8f8f0f; WORD $0xffff // jg LBB5_6, $-113(%rip) + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 -LBB8_10: - WORD $0xdb84 // testb %bl, %bl - LONG $0x006b840f; WORD $0x0000 // je LBB8_14, $107(%rip) - LONG $0x6f0f41f3; WORD $0x005d // movdqu (%r13), %xmm3 - LONG $0xe36f0f66 // movdqa %xmm3, %xmm4 - LONG $0xeb6f0f66 // movdqa %xmm3, %xmm5 - LONG $0xeada0f66 // pminub %xmm2, %xmm5 - LONG $0xeb740f66 // pcmpeqb %xmm3, %xmm5 - LONG $0x7e0f4866; BYTE $0xd9 // movq %xmm3, %rcx - LONG $0xd8740f66 // pcmpeqb %xmm0, %xmm3 - LONG $0xe1740f66 // pcmpeqb %xmm1, %xmm4 - LONG $0xe3eb0f66 // por %xmm3, %xmm4 - LONG $0xeceb0f66 // por %xmm4, %xmm5 - LONG $0xd5d70f66 // pmovmskb %xmm5, %edx +LBB5_9: + WORD $0xd284 // testb %dl, %dl + LONG $0x0077840f; WORD $0x0000 // je LBB5_13, $119(%rip) + LONG $0xd06d894c // movq %r13, $-48(%rbp) + LONG $0x6f0f41f3; WORD $0x2424 // movdqu (%r12), %xmm4 + LONG $0xe86f0f66 // movdqa %xmm0, %xmm5 + LONG $0xec640f66 // pcmpgtb %xmm4, %xmm5 + LONG $0xf46f0f66 // movdqa %xmm4, %xmm6 + LONG $0xf1740f66 // pcmpeqb %xmm1, %xmm6 + LONG $0xfc6f0f66 // movdqa %xmm4, %xmm7 + LONG $0xfa740f66 // pcmpeqb %xmm2, %xmm7 + LONG $0xfeeb0f66 // por %xmm6, %xmm7 + LONG $0x7e0f4866; BYTE $0xe1 // movq %xmm4, %rcx + LONG $0xe3640f66 // pcmpgtb %xmm3, %xmm4 + LONG $0xe5db0f66 // pand %xmm5, %xmm4 + LONG $0xe7eb0f66 // por %xmm7, %xmm4 + LONG $0xd4d70f66 // pmovmskb %xmm4, %edx LONG $0x0000ca81; WORD $0x0001 // orl $65536, %edx - LONG $0xdabc0f44 // bsfl %edx, %r11d - WORD $0x394d; BYTE $0xdc // cmpq %r11, %r12 - LONG $0x00c88d0f; WORD $0x0000 // jge LBB8_24, $200(%rip) - LONG $0x08fc8349 // cmpq $8, %r12 - LONG $0x00fd820f; WORD $0x0000 // jb LBB8_28, $253(%rip) + LONG $0xeabc0f44 // bsfl %edx, %r13d + WORD $0x394d; BYTE $0xe9 // cmpq %r13, %r9 + LONG $0x00c18d0f; WORD $0x0000 // jge LBB5_19, $193(%rip) + LONG $0x08f98349 // cmpq $8, %r9 + LONG $0x0102820f; WORD $0x0000 // jb LBB5_22, $258(%rip) WORD $0x8949; BYTE $0x0f // movq %rcx, (%r15) - LONG $0x085d8d4d // leaq $8(%r13), %r11 + LONG $0x246c8d4d; BYTE $0x08 // leaq $8(%r12), %r13 LONG $0x08c78349 // addq $8, %r15 - LONG $0x245c8d49; BYTE $0xf8 // leaq $-8(%r12), %rbx - LONG $0x04fb8348 // cmpq $4, %rbx - LONG $0x00f38d0f; WORD $0x0000 // jge LBB8_29, $243(%rip) - LONG $0x000100e9; BYTE $0x00 // jmp LBB8_30, $256(%rip) + LONG $0xf8718d49 // leaq $-8(%r9), %rsi + LONG $0x04fe8348 // cmpq $4, %rsi + LONG $0x00f88d0f; WORD $0x0000 // jge LBB5_23, $248(%rip) + LONG $0x000106e9; BYTE $0x00 // jmp LBB5_24, $262(%rip) -LBB8_14: - WORD $0x854d; BYTE $0xdb // testq %r11, %r11 - LONG $0x006e8e0f; WORD $0x0000 // jle LBB8_21, $110(%rip) - WORD $0x854d; BYTE $0xe4 // testq %r12, %r12 - LONG $0x00658e0f; WORD $0x0000 // jle LBB8_21, $101(%rip) - LONG $0xb84d894c // movq %r9, $-72(%rbp) - WORD $0x3145; BYTE $0xc9 // xorl %r9d, %r9d - WORD $0xd231 // xorl %edx, %edx - QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90 +LBB5_13: + WORD $0x854d; BYTE $0xc9 // testq %r9, %r9 + LONG $0x01488e0f; WORD $0x0000 // jle LBB5_28, $328(%rip) + WORD $0x8948; BYTE $0xca // movq %rcx, %rdx + WORD $0x8548; BYTE $0xc9 // testq %rcx, %rcx + LONG $0x013f8e0f; WORD $0x0000 // jle LBB5_29, $319(%rip) + QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90 -LBB8_17: - LONG $0x4cb60f43; WORD $0x000d // movzbl (%r13,%r9), %ecx - WORD $0x8948; BYTE $0xcb // movq %rcx, %rbx - LONG $0x04e3c148 // shlq $4, %rbx - LONG $0x9c358d48; WORD $0x00c5; BYTE $0x00 // leaq $50588(%rip), %rsi /* __SingleQuoteTab(%rip) */ - LONG $0x333c8348; BYTE $0x00 // cmpq $0, (%rbx,%rsi) - LONG $0x008b850f; WORD $0x0000 // jne LBB8_27, $139(%rip) - LONG $0x13048d4d // leaq (%r11,%rdx), %r8 - LONG $0x0f0c8843 // movb %cl, (%r15,%r9) - LONG $0xff5a8d48 // leaq $-1(%rdx), %rbx - LONG $0x02f88349 // cmpq $2, %r8 - LONG $0x00138c0f; WORD $0x0000 // jl LBB8_20, $19(%rip) - WORD $0x014c; BYTE $0xe2 // addq %r12, %rdx - WORD $0xff49; BYTE $0xc1 // incq %r9 - LONG $0x01fa8348 // cmpq $1, %rdx - WORD $0x8948; BYTE $0xda // movq %rbx, %rdx - LONG $0xffb88f0f; WORD $0xffff // jg LBB8_17, $-72(%rip) - -LBB8_20: - WORD $0x2949; BYTE $0xdd // subq %rbx, %r13 - WORD $0x0149; BYTE $0xdb // addq %rbx, %r11 - LONG $0xb84d8b4c // movq $-72(%rbp), %r9 - -LBB8_21: - WORD $0x854d; BYTE $0xdb // testq %r11, %r11 - LONG $0xc0658b4c // movq $-64(%rbp), %r12 - LONG $0x0043840f; WORD $0x0000 // je LBB8_26, $67(%rip) - WORD $0xf749; BYTE $0xd5 // notq %r13 - WORD $0x014d; BYTE $0xcd // addq %r9, %r13 - LONG $0x000129e9; BYTE $0x00 // jmp LBB8_41, $297(%rip) - -LBB8_23: - LONG $0xc9bc0f66 // bsfw %cx, %cx - LONG $0xe9b70f44 // movzwl %cx, %r13d - WORD $0x014d; BYTE $0xfd // addq %r15, %r13 - LONG $0x000115e9; BYTE $0x00 // jmp LBB8_40, $277(%rip) - -LBB8_24: - LONG $0x08fb8341 // cmpl $8, %r11d - LONG $0x00a4820f; WORD $0x0000 // jb LBB8_34, $164(%rip) +LBB5_15: + LONG $0x34b60f41; BYTE $0x24 // movzbl (%r12), %esi + WORD $0x8948; BYTE $0xf2 // movq %rsi, %rdx + LONG $0x04e2c148 // shlq $4, %rdx + LONG $0xdd1d8d48; WORD $0x00d0; BYTE $0x00 // leaq $53469(%rip), %rbx /* __SingleQuoteTab(%rip) */ + LONG $0x1a3c8348; BYTE $0x00 // cmpq $0, (%rdx,%rbx) + LONG $0x0082850f; WORD $0x0000 // jne LBB5_21, $130(%rip) + LONG $0xff518d48 // leaq $-1(%rcx), %rdx + WORD $0xff49; BYTE $0xc4 // incq %r12 + WORD $0x8841; BYTE $0x37 // movb %sil, (%r15) + LONG $0x02f98348 // cmpq $2, %rcx + LONG $0x01018c0f; WORD $0x0000 // jl LBB5_29, $257(%rip) + LONG $0xff718d49 // leaq $-1(%r9), %rsi + WORD $0xff49; BYTE $0xc7 // incq %r15 + WORD $0x8948; BYTE $0xd1 // movq %rdx, %rcx + LONG $0x01f98349 // cmpq $1, %r9 + WORD $0x8949; BYTE $0xf1 // movq %rsi, %r9 + LONG $0xffb78f0f; WORD $0xffff // jg LBB5_15, $-73(%rip) + LONG $0x0000e5e9; BYTE $0x00 // jmp LBB5_29, $229(%rip) + +LBB5_18: + WORD $0xb70f; BYTE $0xc9 // movzwl %cx, %ecx + WORD $0x294d; BYTE $0xd4 // subq %r10, %r12 + LONG $0xc9bc0f44 // bsfl %ecx, %r9d + WORD $0x014d; BYTE $0xe1 // addq %r12, %r9 + WORD $0x854d; BYTE $0xc9 // testq %r9, %r9 + LONG $0xc87d8b4c // movq $-56(%rbp), %r15 + QUAD $0x000300000001bc49; WORD $0x0000 // movabsq $12884901889, %r12 + LONG $0x0167890f; WORD $0x0000 // jns LBB5_37, $359(%rip) + LONG $0x0004bbe9; BYTE $0x00 // jmp LBB5_78, $1211(%rip) + +LBB5_19: + LONG $0x08fd8341 // cmpl $8, %r13d + LONG $0x00da820f; WORD $0x0000 // jb LBB5_30, $218(%rip) WORD $0x8949; BYTE $0x0f // movq %rcx, (%r15) - LONG $0x08658d4d // leaq $8(%r13), %r12 + LONG $0x24748d49; BYTE $0x08 // leaq $8(%r12), %rsi LONG $0x08c78349 // addq $8, %r15 - LONG $0xf85b8d49 // leaq $-8(%r11), %rbx - LONG $0x04fb8348 // cmpq $4, %rbx - LONG $0x009b830f; WORD $0x0000 // jae LBB8_35, $155(%rip) - LONG $0x0000a9e9; BYTE $0x00 // jmp LBB8_36, $169(%rip) - -LBB8_26: - WORD $0x294d; BYTE $0xcd // subq %r9, %r13 - LONG $0x0000e9e9; BYTE $0x00 // jmp LBB8_41, $233(%rip) - -LBB8_27: - LONG $0xb84d8b4c // movq $-72(%rbp), %r9 - WORD $0x294d; BYTE $0xcd // subq %r9, %r13 - WORD $0x2949; BYTE $0xd5 // subq %rdx, %r13 - LONG $0x0000d6e9; BYTE $0x00 // jmp LBB8_40, $214(%rip) - -LBB8_28: - WORD $0x894d; BYTE $0xeb // movq %r13, %r11 - WORD $0x894c; BYTE $0xe3 // movq %r12, %rbx + LONG $0xf85d8d49 // leaq $-8(%r13), %rbx LONG $0x04fb8348 // cmpq $4, %rbx - LONG $0x00128c0f; WORD $0x0000 // jl LBB8_30, $18(%rip) - -LBB8_29: - WORD $0x8b41; BYTE $0x0b // movl (%r11), %ecx + LONG $0x00d08d0f; WORD $0x0000 // jge LBB5_31, $208(%rip) + LONG $0x0000dce9; BYTE $0x00 // jmp LBB5_32, $220(%rip) + +LBB5_21: + WORD $0x294d; BYTE $0xd4 // subq %r10, %r12 + WORD $0x894d; BYTE $0xe1 // movq %r12, %r9 + WORD $0x854d; BYTE $0xc9 // testq %r9, %r9 + LONG $0xc87d8b4c // movq $-56(%rbp), %r15 + QUAD $0x000300000001bc49; WORD $0x0000 // movabsq $12884901889, %r12 + LONG $0x011c890f; WORD $0x0000 // jns LBB5_37, $284(%rip) + LONG $0x000470e9; BYTE $0x00 // jmp LBB5_78, $1136(%rip) + +LBB5_22: + WORD $0x894d; BYTE $0xe5 // movq %r12, %r13 + WORD $0x894c; BYTE $0xce // movq %r9, %rsi + LONG $0x04fe8348 // cmpq $4, %rsi + LONG $0x00138c0f; WORD $0x0000 // jl LBB5_24, $19(%rip) + +LBB5_23: + LONG $0x004d8b41 // movl (%r13), %ecx WORD $0x8941; BYTE $0x0f // movl %ecx, (%r15) - LONG $0x04c38349 // addq $4, %r11 + LONG $0x04c58349 // addq $4, %r13 LONG $0x04c78349 // addq $4, %r15 - LONG $0xfcc38348 // addq $-4, %rbx + LONG $0xfcc68348 // addq $-4, %rsi -LBB8_30: - LONG $0x02fb8348 // cmpq $2, %rbx - LONG $0x0022820f; WORD $0x0000 // jb LBB8_31, $34(%rip) - LONG $0x0bb70f41 // movzwl (%r11), %ecx +LBB5_24: + LONG $0x02fe8348 // cmpq $2, %rsi + LONG $0x0023820f; WORD $0x0000 // jb LBB5_25, $35(%rip) + LONG $0x4db70f41; BYTE $0x00 // movzwl (%r13), %ecx LONG $0x0f894166 // movw %cx, (%r15) - LONG $0x02c38349 // addq $2, %r11 + LONG $0x02c58349 // addq $2, %r13 LONG $0x02c78349 // addq $2, %r15 - LONG $0xfec38348 // addq $-2, %rbx - WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx - LONG $0x000e850f; WORD $0x0000 // jne LBB8_32, $14(%rip) - LONG $0x000010e9; BYTE $0x00 // jmp LBB8_33, $16(%rip) + LONG $0xfec68348 // addq $-2, %rsi + WORD $0x8548; BYTE $0xf6 // testq %rsi, %rsi + LONG $0x000e850f; WORD $0x0000 // jne LBB5_26, $14(%rip) + LONG $0x000010e9; BYTE $0x00 // jmp LBB5_27, $16(%rip) -LBB8_31: - WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx - LONG $0x0007840f; WORD $0x0000 // je LBB8_33, $7(%rip) +LBB5_25: + WORD $0x8548; BYTE $0xf6 // testq %rsi, %rsi + LONG $0x0007840f; WORD $0x0000 // je LBB5_27, $7(%rip) -LBB8_32: - LONG $0x0bb60f41 // movzbl (%r11), %ecx +LBB5_26: + LONG $0x004d8a41 // movb (%r13), %cl WORD $0x8841; BYTE $0x0f // movb %cl, (%r15) -LBB8_33: - WORD $0x014d; BYTE $0xec // addq %r13, %r12 - WORD $0xf749; BYTE $0xd4 // notq %r12 - WORD $0x014d; BYTE $0xcc // addq %r9, %r12 - WORD $0x894d; BYTE $0xe5 // movq %r12, %r13 - LONG $0x000067e9; BYTE $0x00 // jmp LBB8_40, $103(%rip) +LBB5_27: + WORD $0x294d; BYTE $0xd1 // subq %r10, %r9 + WORD $0x014d; BYTE $0xe1 // addq %r12, %r9 + WORD $0xf749; BYTE $0xd1 // notq %r9 + LONG $0x00008ee9; BYTE $0x00 // jmp LBB5_36, $142(%rip) -LBB8_34: - WORD $0x894d; BYTE $0xec // movq %r13, %r12 - WORD $0x894c; BYTE $0xdb // movq %r11, %rbx +LBB5_28: + WORD $0x8948; BYTE $0xca // movq %rcx, %rdx + +LBB5_29: + WORD $0x294d; BYTE $0xd4 // subq %r10, %r12 + WORD $0xf748; BYTE $0xda // negq %rdx + WORD $0x194d; BYTE $0xc9 // sbbq %r9, %r9 + WORD $0x314d; BYTE $0xe1 // xorq %r12, %r9 + WORD $0x854d; BYTE $0xc9 // testq %r9, %r9 + LONG $0xc87d8b4c // movq $-56(%rbp), %r15 + QUAD $0x000300000001bc49; WORD $0x0000 // movabsq $12884901889, %r12 + LONG $0x0083890f; WORD $0x0000 // jns LBB5_37, $131(%rip) + LONG $0x0003d7e9; BYTE $0x00 // jmp LBB5_78, $983(%rip) + +LBB5_30: + WORD $0x894c; BYTE $0xe6 // movq %r12, %rsi + WORD $0x894c; BYTE $0xeb // movq %r13, %rbx LONG $0x04fb8348 // cmpq $4, %rbx - LONG $0x0013820f; WORD $0x0000 // jb LBB8_36, $19(%rip) + LONG $0x00118c0f; WORD $0x0000 // jl LBB5_32, $17(%rip) -LBB8_35: - LONG $0x240c8b41 // movl (%r12), %ecx +LBB5_31: + WORD $0x0e8b // movl (%rsi), %ecx WORD $0x8941; BYTE $0x0f // movl %ecx, (%r15) - LONG $0x04c48349 // addq $4, %r12 + LONG $0x04c68348 // addq $4, %rsi LONG $0x04c78349 // addq $4, %r15 LONG $0xfcc38348 // addq $-4, %rbx -LBB8_36: +LBB5_32: LONG $0x02fb8348 // cmpq $2, %rbx - LONG $0x0023820f; WORD $0x0000 // jb LBB8_37, $35(%rip) - LONG $0x0cb70f41; BYTE $0x24 // movzwl (%r12), %ecx + LONG $0x0021820f; WORD $0x0000 // jb LBB5_33, $33(%rip) + WORD $0xb70f; BYTE $0x0e // movzwl (%rsi), %ecx LONG $0x0f894166 // movw %cx, (%r15) - LONG $0x02c48349 // addq $2, %r12 + LONG $0x02c68348 // addq $2, %rsi LONG $0x02c78349 // addq $2, %r15 LONG $0xfec38348 // addq $-2, %rbx WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx - LONG $0x000e850f; WORD $0x0000 // jne LBB8_38, $14(%rip) - LONG $0x000011e9; BYTE $0x00 // jmp LBB8_39, $17(%rip) + LONG $0x000e850f; WORD $0x0000 // jne LBB5_34, $14(%rip) + LONG $0x00000ee9; BYTE $0x00 // jmp LBB5_35, $14(%rip) -LBB8_37: +LBB5_33: WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx - LONG $0x0008840f; WORD $0x0000 // je LBB8_39, $8(%rip) - -LBB8_38: - LONG $0x0cb60f41; BYTE $0x24 // movzbl (%r12), %ecx - WORD $0x8841; BYTE $0x0f // movb %cl, (%r15) + LONG $0x0005840f; WORD $0x0000 // je LBB5_35, $5(%rip) -LBB8_39: - WORD $0x294d; BYTE $0xcd // subq %r9, %r13 - WORD $0x014d; BYTE $0xdd // addq %r11, %r13 - -LBB8_40: - LONG $0xc0658b4c // movq $-64(%rbp), %r12 - -LBB8_41: - QUAD $0x000300000001bb49; WORD $0x0000 // movabsq $12884901889, %r11 - WORD $0x854d; BYTE $0xed // testq %r13, %r13 - LONG $0x0323880f; WORD $0x0000 // js LBB8_82, $803(%rip) - WORD $0x014d; BYTE $0xee // addq %r13, %r14 - WORD $0x394c; BYTE $0xe8 // cmpq %r13, %rax - LONG $0x00c2840f; WORD $0x0000 // je LBB8_78, $194(%rip) - WORD $0x294d; BYTE $0xea // subq %r13, %r10 - LONG $0x000015e9; BYTE $0x00 // jmp LBB8_45, $21(%rip) - LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 - -LBB8_44: - WORD $0x0149; BYTE $0xf6 // addq %rsi, %r14 - WORD $0xff49; BYTE $0xc5 // incq %r13 - WORD $0x394c; BYTE $0xe8 // cmpq %r13, %rax - LONG $0x00a5840f; WORD $0x0000 // je LBB8_78, $165(%rip) +LBB5_34: + WORD $0x0e8a // movb (%rsi), %cl + WORD $0x8841; BYTE $0x0f // movb %cl, (%r15) -LBB8_45: - LONG $0x0cb60f43; BYTE $0x29 // movzbl (%r9,%r13), %ecx - LONG $0x04e1c148 // shlq $4, %rcx - LONG $0x0c148b41 // movl (%r12,%rcx), %edx - WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx - LONG $0x0082840f; WORD $0x0000 // je LBB8_53, $130(%rip) - WORD $0x6348; BYTE $0xf2 // movslq %edx, %rsi - WORD $0x2949; BYTE $0xf2 // subq %rsi, %r10 - LONG $0x02b28c0f; WORD $0x0000 // jl LBB8_80, $690(%rip) - LONG $0x20e2c148 // shlq $32, %rdx - LONG $0x0c1c8d49 // leaq (%r12,%rcx), %rbx - LONG $0x08c38348 // addq $8, %rbx - WORD $0x394c; BYTE $0xda // cmpq %r11, %rdx - LONG $0x002a8c0f; WORD $0x0000 // jl LBB8_49, $42(%rip) - WORD $0x0b8b // movl (%rbx), %ecx - WORD $0x8941; BYTE $0x0e // movl %ecx, (%r14) - LONG $0x04c38348 // addq $4, %rbx - LONG $0x04468d4d // leaq $4(%r14), %r8 - LONG $0xfc4e8d48 // leaq $-4(%rsi), %rcx - LONG $0x02f98348 // cmpq $2, %rcx - LONG $0x001f830f; WORD $0x0000 // jae LBB8_50, $31(%rip) - LONG $0x00002de9; BYTE $0x00 // jmp LBB8_51, $45(%rip) - QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90 +LBB5_35: + WORD $0x294d; BYTE $0xd4 // subq %r10, %r12 + WORD $0x014d; BYTE $0xec // addq %r13, %r12 + WORD $0x894d; BYTE $0xe1 // movq %r12, %r9 + +LBB5_36: + LONG $0xd06d8b4c // movq $-48(%rbp), %r13 + WORD $0x854d; BYTE $0xc9 // testq %r9, %r9 + LONG $0xc87d8b4c // movq $-56(%rbp), %r15 + QUAD $0x000300000001bc49; WORD $0x0000 // movabsq $12884901889, %r12 + LONG $0x0359880f; WORD $0x0000 // js LBB5_78, $857(%rip) + +LBB5_37: + WORD $0x014d; BYTE $0xca // addq %r9, %r10 + WORD $0x014d; BYTE $0xce // addq %r9, %r14 + WORD $0x394c; BYTE $0xc8 // cmpq %r9, %rax + LONG $0x00cc840f; WORD $0x0000 // je LBB5_74, $204(%rip) + WORD $0x294d; BYTE $0xcb // subq %r9, %r11 + WORD $0x2949; BYTE $0xc1 // subq %rax, %r9 + LONG $0x00001ce9; BYTE $0x00 // jmp LBB5_40, $28(%rip) + QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 -LBB8_49: - WORD $0x894d; BYTE $0xf0 // movq %r14, %r8 - WORD $0x8948; BYTE $0xf1 // movq %rsi, %rcx - LONG $0x02f98348 // cmpq $2, %rcx - LONG $0x0013820f; WORD $0x0000 // jb LBB8_51, $19(%rip) +LBB5_39: + WORD $0xff49; BYTE $0xc2 // incq %r10 + WORD $0x0149; BYTE $0xc6 // addq %rax, %r14 + WORD $0xff49; BYTE $0xc1 // incq %r9 + LONG $0x00a5840f; WORD $0x0000 // je LBB5_74, $165(%rip) + +LBB5_40: + LONG $0x12b60f41 // movzbl (%r10), %edx + LONG $0x04e2c148 // shlq $4, %rdx + LONG $0x10348b49 // movq (%r8,%rdx), %rsi + WORD $0xf685 // testl %esi, %esi + LONG $0x0082840f; WORD $0x0000 // je LBB5_48, $130(%rip) + WORD $0x6348; BYTE $0xc6 // movslq %esi, %rax + WORD $0x2949; BYTE $0xc3 // subq %rax, %r11 + LONG $0x02e48c0f; WORD $0x0000 // jl LBB5_75, $740(%rip) + LONG $0x20e6c148 // shlq $32, %rsi + LONG $0x104c8d49; BYTE $0x08 // leaq $8(%r8,%rdx), %rcx + WORD $0x394c; BYTE $0xe6 // cmpq %r12, %rsi + LONG $0x002f8c0f; WORD $0x0000 // jl LBB5_44, $47(%rip) + WORD $0x098b // movl (%rcx), %ecx + WORD $0x8941; BYTE $0x0e // movl %ecx, (%r14) + LONG $0x104c8d49; BYTE $0x0c // leaq $12(%r8,%rdx), %rcx + LONG $0x04568d49 // leaq $4(%r14), %rdx + LONG $0xfc708d48 // leaq $-4(%rax), %rsi + LONG $0x02fe8348 // cmpq $2, %rsi + LONG $0x0023830f; WORD $0x0000 // jae LBB5_45, $35(%rip) + LONG $0x000030e9; BYTE $0x00 // jmp LBB5_46, $48(%rip) + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 -LBB8_50: - WORD $0xb70f; BYTE $0x13 // movzwl (%rbx), %edx - LONG $0x10894166 // movw %dx, (%r8) - LONG $0x02c38348 // addq $2, %rbx - LONG $0x02c08349 // addq $2, %r8 - LONG $0xfec18348 // addq $-2, %rcx +LBB5_44: + WORD $0x894c; BYTE $0xf2 // movq %r14, %rdx + WORD $0x8948; BYTE $0xc6 // movq %rax, %rsi + LONG $0x02fe8348 // cmpq $2, %rsi + LONG $0x0012820f; WORD $0x0000 // jb LBB5_46, $18(%rip) -LBB8_51: - WORD $0x8548; BYTE $0xc9 // testq %rcx, %rcx - LONG $0xff64840f; WORD $0xffff // je LBB8_44, $-156(%rip) - WORD $0xb60f; BYTE $0x0b // movzbl (%rbx), %ecx - WORD $0x8841; BYTE $0x08 // movb %cl, (%r8) - LONG $0xffff59e9; BYTE $0xff // jmp LBB8_44, $-167(%rip) +LBB5_45: + WORD $0xb70f; BYTE $0x19 // movzwl (%rcx), %ebx + WORD $0x8966; BYTE $0x1a // movw %bx, (%rdx) + LONG $0x02c18348 // addq $2, %rcx + LONG $0x02c28348 // addq $2, %rdx + LONG $0xfec68348 // addq $-2, %rsi -LBB8_53: - LONG $0x290c8d4b // leaq (%r9,%r13), %rcx - WORD $0x294c; BYTE $0xe8 // subq %r13, %rax - LONG $0xfc59850f; WORD $0xffff // jne LBB8_3, $-935(%rip) +LBB5_46: + WORD $0x8548; BYTE $0xf6 // testq %rsi, %rsi + LONG $0xff65840f; WORD $0xffff // je LBB5_39, $-155(%rip) + WORD $0xb60f; BYTE $0x09 // movzbl (%rcx), %ecx + WORD $0x0a88 // movb %cl, (%rdx) + LONG $0xffff5be9; BYTE $0xff // jmp LBB5_39, $-165(%rip) -LBB8_78: - WORD $0x014d; BYTE $0xe9 // addq %r13, %r9 - LONG $0xc85d8b4c // movq $-56(%rbp), %r11 - LONG $0xd07d8b4c // movq $-48(%rbp), %r15 +LBB5_48: + WORD $0x894c; BYTE $0xc8 // movq %r9, %rax + WORD $0xf748; BYTE $0xd8 // negq %rax + WORD $0x854d; BYTE $0xc9 // testq %r9, %r9 + LONG $0xfbf5850f; WORD $0xffff // jne LBB5_3, $-1035(%rip) -LBB8_79: +LBB5_74: WORD $0x294d; BYTE $0xfe // subq %r15, %r14 - WORD $0x894d; BYTE $0x33 // movq %r14, (%r11) - WORD $0x2949; BYTE $0xf9 // subq %rdi, %r9 - WORD $0x894c; BYTE $0xc8 // movq %r9, %rax - LONG $0x00022ae9; BYTE $0x00 // jmp LBB8_81, $554(%rip) - -LBB8_56: - QUAD $0xfffffb88056f0f66 // movdqa $-1144(%rip), %xmm0 /* LCPI8_0(%rip) */ - QUAD $0xfffffb900d6f0f66 // movdqa $-1136(%rip), %xmm1 /* LCPI8_1(%rip) */ - QUAD $0xfffffb98156f0f66 // movdqa $-1128(%rip), %xmm2 /* LCPI8_2(%rip) */ - LONG $0x010d8d4c; WORD $0x00e3; BYTE $0x00 // leaq $58113(%rip), %r9 /* __EscTab(%rip) */ - WORD $0x894c; BYTE $0xfe // movq %r15, %rsi - WORD $0x8948; BYTE $0xc3 // movq %rax, %rbx + LONG $0x0075894d // movq %r14, (%r13) + WORD $0x2949; BYTE $0xfa // subq %rdi, %r10 + LONG $0x00025de9; BYTE $0x00 // jmp LBB5_76, $605(%rip) + +LBB5_51: + LONG $0x260d8d4c; WORD $0x00ee; BYTE $0x00 // leaq $60966(%rip), %r9 /* __EscTab(%rip) */ + QUAD $0xfffffb2e056f0f66 // movdqa $-1234(%rip), %xmm0 /* LCPI5_0(%rip) */ + QUAD $0xfffffb360d6f0f66 // movdqa $-1226(%rip), %xmm1 /* LCPI5_1(%rip) */ + QUAD $0xfffffb3e156f0f66 // movdqa $-1218(%rip), %xmm2 /* LCPI5_2(%rip) */ + LONG $0xdb760f66 // pcmpeqd %xmm3, %xmm3 + WORD $0x894c; BYTE $0xfb // movq %r15, %rbx + WORD $0x8949; BYTE $0xc2 // movq %rax, %r10 + +LBB5_52: + LONG $0x10fa8349 // cmpq $16, %r10 + LONG $0x00698c0f; WORD $0x0000 // jl LBB5_57, $105(%rip) + LONG $0x000010b9; BYTE $0x00 // movl $16, %ecx + WORD $0xd231 // xorl %edx, %edx + WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 -LBB8_57: - LONG $0x10fb8348 // cmpq $16, %rbx - LONG $0x004b8c0f; WORD $0x0000 // jl LBB8_60, $75(%rip) - BYTE $0x90 // .p2align 4, 0x90 +LBB5_54: + LONG $0x246f0ff3; BYTE $0x17 // movdqu (%rdi,%rdx), %xmm4 + LONG $0xe86f0f66 // movdqa %xmm0, %xmm5 + LONG $0xec640f66 // pcmpgtb %xmm4, %xmm5 + LONG $0xf46f0f66 // movdqa %xmm4, %xmm6 + LONG $0xf1740f66 // pcmpeqb %xmm1, %xmm6 + LONG $0xfc6f0f66 // movdqa %xmm4, %xmm7 + LONG $0xfa740f66 // pcmpeqb %xmm2, %xmm7 + LONG $0xfeeb0f66 // por %xmm6, %xmm7 + LONG $0x247f0ff3; BYTE $0x13 // movdqu %xmm4, (%rbx,%rdx) + LONG $0xe3640f66 // pcmpgtb %xmm3, %xmm4 + LONG $0xe5db0f66 // pand %xmm5, %xmm4 + LONG $0xe7eb0f66 // por %xmm7, %xmm4 + LONG $0xf4d70f66 // pmovmskb %xmm4, %esi + WORD $0x8566; BYTE $0xf6 // testw %si, %si + LONG $0x013d850f; WORD $0x0000 // jne LBB5_67, $317(%rip) + LONG $0x10c28348 // addq $16, %rdx + LONG $0x0a748d49; BYTE $0xf0 // leaq $-16(%r10,%rcx), %rsi + LONG $0xf0c18348 // addq $-16, %rcx + LONG $0x1ffe8348 // cmpq $31, %rsi + LONG $0xffaa8f0f; WORD $0xffff // jg LBB5_54, $-86(%rip) + WORD $0x0148; BYTE $0xd7 // addq %rdx, %rdi + WORD $0x2949; BYTE $0xd2 // subq %rdx, %r10 + WORD $0x0148; BYTE $0xd3 // addq %rdx, %rbx -LBB8_58: - LONG $0x1f6f0ff3 // movdqu (%rdi), %xmm3 - LONG $0xe36f0f66 // movdqa %xmm3, %xmm4 - LONG $0x1e7f0ff3 // movdqu %xmm3, (%rsi) - LONG $0xeb6f0f66 // movdqa %xmm3, %xmm5 - LONG $0xeada0f66 // pminub %xmm2, %xmm5 - LONG $0xeb740f66 // pcmpeqb %xmm3, %xmm5 - LONG $0xd8740f66 // pcmpeqb %xmm0, %xmm3 - LONG $0xe1740f66 // pcmpeqb %xmm1, %xmm4 - LONG $0xe3eb0f66 // por %xmm3, %xmm4 - LONG $0xeceb0f66 // por %xmm4, %xmm5 - LONG $0xcdd70f66 // pmovmskb %xmm5, %ecx - WORD $0xc985 // testl %ecx, %ecx - LONG $0x0128850f; WORD $0x0000 // jne LBB8_70, $296(%rip) - LONG $0x10c78348 // addq $16, %rdi - LONG $0x10c68348 // addq $16, %rsi - LONG $0xf0c38348 // addq $-16, %rbx - LONG $0x10fb8348 // cmpq $16, %rbx - LONG $0xffb6830f; WORD $0xffff // jae LBB8_58, $-74(%rip) - -LBB8_60: - LONG $0x08fb8348 // cmpq $8, %rbx - LONG $0x007b8c0f; WORD $0x0000 // jl LBB8_64, $123(%rip) +LBB5_57: + LONG $0x08fa8349 // cmpq $8, %r10 + LONG $0x00858c0f; WORD $0x0000 // jl LBB5_61, $133(%rip) WORD $0xb60f; BYTE $0x0f // movzbl (%rdi), %ecx + LONG $0x0cb60f42; BYTE $0x09 // movzbl (%rcx,%r9), %ecx LONG $0x0157b60f // movzbl $1(%rdi), %edx LONG $0x14b60f42; BYTE $0x0a // movzbl (%rdx,%r9), %edx - WORD $0xd200 // addb %dl, %dl - LONG $0x09140a42 // orb (%rcx,%r9), %dl + WORD $0xd201 // addl %edx, %edx + WORD $0xca09 // orl %ecx, %edx LONG $0x024fb60f // movzbl $2(%rdi), %ecx + LONG $0x34b60f42; BYTE $0x09 // movzbl (%rcx,%r9), %esi + WORD $0xe6c1; BYTE $0x02 // shll $2, %esi + LONG $0x034fb60f // movzbl $3(%rdi), %ecx LONG $0x0cb60f42; BYTE $0x09 // movzbl (%rcx,%r9), %ecx - WORD $0xe1c0; BYTE $0x02 // shlb $2, %cl - WORD $0xd108 // orb %dl, %cl - LONG $0x0357b60f // movzbl $3(%rdi), %edx - LONG $0x14b60f42; BYTE $0x0a // movzbl (%rdx,%r9), %edx - WORD $0xe2c0; BYTE $0x03 // shlb $3, %dl - WORD $0xca08 // orb %cl, %dl - WORD $0x8b48; BYTE $0x0f // movq (%rdi), %rcx - WORD $0x8948; BYTE $0x0e // movq %rcx, (%rsi) - LONG $0x011f850f; WORD $0x0000 // jne LBB8_75, $287(%rip) + WORD $0xe1c1; BYTE $0x03 // shll $3, %ecx + WORD $0xf109 // orl %esi, %ecx + WORD $0xd109 // orl %edx, %ecx + WORD $0x8b48; BYTE $0x17 // movq (%rdi), %rdx + WORD $0x8948; BYTE $0x13 // movq %rdx, (%rbx) + WORD $0xc984 // testb %cl, %cl + LONG $0x0135850f; WORD $0x0000 // jne LBB5_71, $309(%rip) LONG $0x044fb60f // movzbl $4(%rdi), %ecx + LONG $0x0cb60f42; BYTE $0x09 // movzbl (%rcx,%r9), %ecx LONG $0x0557b60f // movzbl $5(%rdi), %edx LONG $0x14b60f42; BYTE $0x0a // movzbl (%rdx,%r9), %edx - WORD $0xd200 // addb %dl, %dl - LONG $0x09140a42 // orb (%rcx,%r9), %dl + WORD $0xd201 // addl %edx, %edx + WORD $0xca09 // orl %ecx, %edx LONG $0x064fb60f // movzbl $6(%rdi), %ecx + LONG $0x34b60f42; BYTE $0x09 // movzbl (%rcx,%r9), %esi + WORD $0xe6c1; BYTE $0x02 // shll $2, %esi + LONG $0x074fb60f // movzbl $7(%rdi), %ecx LONG $0x0cb60f42; BYTE $0x09 // movzbl (%rcx,%r9), %ecx - WORD $0xe1c0; BYTE $0x02 // shlb $2, %cl - WORD $0xd108 // orb %dl, %cl - LONG $0x0757b60f // movzbl $7(%rdi), %edx - LONG $0x14b60f42; BYTE $0x0a // movzbl (%rdx,%r9), %edx - WORD $0xe2c0; BYTE $0x03 // shlb $3, %dl - WORD $0xca08 // orb %cl, %dl - LONG $0x00f5850f; WORD $0x0000 // jne LBB8_76, $245(%rip) - LONG $0x08c68348 // addq $8, %rsi + WORD $0xe1c1; BYTE $0x03 // shll $3, %ecx + WORD $0xf109 // orl %esi, %ecx + WORD $0xd109 // orl %edx, %ecx + WORD $0xc984 // testb %cl, %cl + LONG $0x010c850f; WORD $0x0000 // jne LBB5_72, $268(%rip) + LONG $0x08c38348 // addq $8, %rbx LONG $0x08c78348 // addq $8, %rdi - LONG $0xf8c38348 // addq $-8, %rbx + LONG $0xf8c28349 // addq $-8, %r10 -LBB8_64: - LONG $0x04fb8348 // cmpq $4, %rbx - LONG $0x00448c0f; WORD $0x0000 // jl LBB8_67, $68(%rip) +LBB5_61: + LONG $0x04fa8349 // cmpq $4, %r10 + LONG $0x00498c0f; WORD $0x0000 // jl LBB5_64, $73(%rip) WORD $0xb60f; BYTE $0x0f // movzbl (%rdi), %ecx + LONG $0x0cb60f42; BYTE $0x09 // movzbl (%rcx,%r9), %ecx LONG $0x0157b60f // movzbl $1(%rdi), %edx LONG $0x14b60f42; BYTE $0x0a // movzbl (%rdx,%r9), %edx - WORD $0xd200 // addb %dl, %dl - LONG $0x09140a42 // orb (%rcx,%r9), %dl + WORD $0xd201 // addl %edx, %edx + WORD $0xca09 // orl %ecx, %edx LONG $0x024fb60f // movzbl $2(%rdi), %ecx + LONG $0x34b60f42; BYTE $0x09 // movzbl (%rcx,%r9), %esi + WORD $0xe6c1; BYTE $0x02 // shll $2, %esi + LONG $0x034fb60f // movzbl $3(%rdi), %ecx LONG $0x0cb60f42; BYTE $0x09 // movzbl (%rcx,%r9), %ecx - WORD $0xe1c0; BYTE $0x02 // shlb $2, %cl - WORD $0xd108 // orb %dl, %cl - LONG $0x0357b60f // movzbl $3(%rdi), %edx - LONG $0x14b60f42; BYTE $0x0a // movzbl (%rdx,%r9), %edx - WORD $0xe2c0; BYTE $0x03 // shlb $3, %dl - WORD $0xca08 // orb %cl, %dl - WORD $0x0f8b // movl (%rdi), %ecx - WORD $0x0e89 // movl %ecx, (%rsi) - LONG $0x009c850f; WORD $0x0000 // jne LBB8_75, $156(%rip) - LONG $0x04c68348 // addq $4, %rsi + WORD $0xe1c1; BYTE $0x03 // shll $3, %ecx + WORD $0xf109 // orl %esi, %ecx + WORD $0xd109 // orl %edx, %ecx + WORD $0x178b // movl (%rdi), %edx + WORD $0x1389 // movl %edx, (%rbx) + WORD $0xc984 // testb %cl, %cl + LONG $0x00a8850f; WORD $0x0000 // jne LBB5_71, $168(%rip) + LONG $0x04c38348 // addq $4, %rbx LONG $0x04c78348 // addq $4, %rdi - LONG $0xfcc38348 // addq $-4, %rbx + LONG $0xfcc28349 // addq $-4, %r10 -LBB8_67: - WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx - LONG $0x00b28e0f; WORD $0x0000 // jle LBB8_77, $178(%rip) - QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90 +LBB5_64: + WORD $0x854d; BYTE $0xd2 // testq %r10, %r10 + LONG $0x00bd8e0f; WORD $0x0000 // jle LBB5_73, $189(%rip) + LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 -LBB8_68: +LBB5_65: WORD $0xb60f; BYTE $0x0f // movzbl (%rdi), %ecx LONG $0x093c8042; BYTE $0x00 // cmpb $0, (%rcx,%r9) - LONG $0x002e850f; WORD $0x0000 // jne LBB8_72, $46(%rip) + LONG $0x0036850f; WORD $0x0000 // jne LBB5_68, $54(%rip) WORD $0xff48; BYTE $0xc7 // incq %rdi - WORD $0x0e88 // movb %cl, (%rsi) - WORD $0xff48; BYTE $0xc6 // incq %rsi - LONG $0xff4b8d48 // leaq $-1(%rbx), %rcx - LONG $0x01fb8348 // cmpq $1, %rbx - WORD $0x8948; BYTE $0xcb // movq %rcx, %rbx - LONG $0xffd98f0f; WORD $0xffff // jg LBB8_68, $-39(%rip) - LONG $0x00007ce9; BYTE $0x00 // jmp LBB8_77, $124(%rip) - -LBB8_70: - LONG $0xc9bc0f66 // bsfw %cx, %cx - WORD $0xb70f; BYTE $0xc9 // movzwl %cx, %ecx + WORD $0x0b88 // movb %cl, (%rbx) + WORD $0xff48; BYTE $0xc3 // incq %rbx + LONG $0xff4a8d49 // leaq $-1(%r10), %rcx + LONG $0x01fa8349 // cmpq $1, %r10 + WORD $0x8949; BYTE $0xca // movq %rcx, %r10 + LONG $0xffd98f0f; WORD $0xffff // jg LBB5_65, $-39(%rip) + LONG $0x00008be9; BYTE $0x00 // jmp LBB5_73, $139(%rip) -LBB8_71: +LBB5_67: + WORD $0xb70f; BYTE $0xce // movzwl %si, %ecx + WORD $0xbc0f; BYTE $0xc9 // bsfl %ecx, %ecx WORD $0x0148; BYTE $0xcf // addq %rcx, %rdi - WORD $0x2948; BYTE $0xcb // subq %rcx, %rbx - WORD $0x0148; BYTE $0xce // addq %rcx, %rsi - -LBB8_72: - WORD $0xb60f; BYTE $0x0f // movzbl (%rdi), %ecx - BYTE $0x90 // .p2align 4, 0x90 + WORD $0x0148; BYTE $0xd7 // addq %rdx, %rdi + WORD $0x2949; BYTE $0xca // subq %rcx, %r10 + WORD $0x2949; BYTE $0xd2 // subq %rdx, %r10 + WORD $0x0148; BYTE $0xcb // addq %rcx, %rbx + WORD $0x0148; BYTE $0xd3 // addq %rdx, %rbx + +LBB5_68: + WORD $0x0f8a // movb (%rdi), %cl + QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90 -LBB8_73: - WORD $0x8948; BYTE $0xf2 // movq %rsi, %rdx +LBB5_69: + WORD $0x8948; BYTE $0xda // movq %rbx, %rdx WORD $0xb60f; BYTE $0xc9 // movzbl %cl, %ecx LONG $0x04e1c148 // shlq $4, %rcx - LONG $0x0c346349 // movslq (%r12,%rcx), %rsi - LONG $0x0c4c8b49; BYTE $0x08 // movq $8(%r12,%rcx), %rcx + LONG $0x081c6349 // movslq (%r8,%rcx), %rbx + LONG $0x084c8b49; BYTE $0x08 // movq $8(%r8,%rcx), %rcx WORD $0x8948; BYTE $0x0a // movq %rcx, (%rdx) - WORD $0x0148; BYTE $0xd6 // addq %rdx, %rsi - LONG $0x02fb8348 // cmpq $2, %rbx - LONG $0x00458c0f; WORD $0x0000 // jl LBB8_77, $69(%rip) - WORD $0xff48; BYTE $0xcb // decq %rbx + WORD $0x0148; BYTE $0xd3 // addq %rdx, %rbx + LONG $0x02fa8349 // cmpq $2, %r10 + LONG $0x00448c0f; WORD $0x0000 // jl LBB5_73, $68(%rip) + WORD $0xff49; BYTE $0xca // decq %r10 LONG $0x014fb60f // movzbl $1(%rdi), %ecx WORD $0xff48; BYTE $0xc7 // incq %rdi LONG $0x093c8042; BYTE $0x00 // cmpb $0, (%rcx,%r9) - LONG $0xffc8850f; WORD $0xffff // jne LBB8_73, $-56(%rip) - LONG $0xfffe48e9; BYTE $0xff // jmp LBB8_57, $-440(%rip) + LONG $0xffc8850f; WORD $0xffff // jne LBB5_69, $-56(%rip) + LONG $0xfffe0fe9; BYTE $0xff // jmp LBB5_52, $-497(%rip) -LBB8_75: - WORD $0xb60f; BYTE $0xca // movzbl %dl, %ecx +LBB5_71: WORD $0xbc0f; BYTE $0xc9 // bsfl %ecx, %ecx - LONG $0xffffabe9; BYTE $0xff // jmp LBB8_71, $-85(%rip) + WORD $0x0148; BYTE $0xcf // addq %rcx, %rdi + WORD $0x2949; BYTE $0xca // subq %rcx, %r10 + WORD $0x0148; BYTE $0xcb // addq %rcx, %rbx + LONG $0xffffa6e9; BYTE $0xff // jmp LBB5_68, $-90(%rip) -LBB8_76: - WORD $0xb60f; BYTE $0xca // movzbl %dl, %ecx +LBB5_72: WORD $0xbc0f; BYTE $0xc9 // bsfl %ecx, %ecx LONG $0x04518d48 // leaq $4(%rcx), %rdx - WORD $0x0148; BYTE $0xcf // addq %rcx, %rdi - LONG $0x04c78348 // addq $4, %rdi - WORD $0x2948; BYTE $0xd3 // subq %rdx, %rbx - WORD $0x0148; BYTE $0xce // addq %rcx, %rsi - LONG $0x04c68348 // addq $4, %rsi - LONG $0xffff94e9; BYTE $0xff // jmp LBB8_72, $-108(%rip) - -LBB8_77: - WORD $0x294c; BYTE $0xfe // subq %r15, %rsi - WORD $0x8949; BYTE $0x33 // movq %rsi, (%r11) - LONG $0x000017e9; BYTE $0x00 // jmp LBB8_81, $23(%rip) - -LBB8_80: - LONG $0xd0752b4c // subq $-48(%rbp), %r14 - LONG $0xc8458b48 // movq $-56(%rbp), %rax - WORD $0x894c; BYTE $0x30 // movq %r14, (%rax) - WORD $0x294c; BYTE $0xcf // subq %r9, %rdi - WORD $0xf749; BYTE $0xd5 // notq %r13 - WORD $0x0149; BYTE $0xfd // addq %rdi, %r13 - WORD $0x894c; BYTE $0xe8 // movq %r13, %rax + LONG $0x0f7c8d48; BYTE $0x04 // leaq $4(%rdi,%rcx), %rdi + WORD $0x2949; BYTE $0xd2 // subq %rdx, %r10 + LONG $0x0b5c8d48; BYTE $0x04 // leaq $4(%rbx,%rcx), %rbx + LONG $0xffff8de9; BYTE $0xff // jmp LBB5_68, $-115(%rip) + +LBB5_73: + WORD $0x294c; BYTE $0xfb // subq %r15, %rbx + LONG $0x005d8949 // movq %rbx, (%r13) + LONG $0x000010e9; BYTE $0x00 // jmp LBB5_77, $16(%rip) + +LBB5_75: + WORD $0x294d; BYTE $0xfe // subq %r15, %r14 + LONG $0x0075894d // movq %r14, (%r13) + WORD $0xf749; BYTE $0xd2 // notq %r10 + WORD $0x0149; BYTE $0xfa // addq %rdi, %r10 + +LBB5_76: + WORD $0x894c; BYTE $0xd0 // movq %r10, %rax -LBB8_81: - LONG $0x20c48348 // addq $32, %rsp +LBB5_77: + LONG $0x10c48348 // addq $16, %rsp BYTE $0x5b // popq %rbx WORD $0x5c41 // popq %r12 WORD $0x5d41 // popq %r13 @@ -2080,20 +1845,19 @@ LBB8_81: BYTE $0x5d // popq %rbp BYTE $0xc3 // retq -LBB8_82: - LONG $0xd04d8b48 // movq $-48(%rbp), %rcx - WORD $0x014c; BYTE $0xe9 // addq %r13, %rcx - WORD $0xf748; BYTE $0xd1 // notq %rcx - WORD $0x014c; BYTE $0xf1 // addq %r14, %rcx - LONG $0xc8458b48 // movq $-56(%rbp), %rax - WORD $0x8948; BYTE $0x08 // movq %rcx, (%rax) - WORD $0x294c; BYTE $0xcf // subq %r9, %rdi - WORD $0x014c; BYTE $0xef // addq %r13, %rdi +LBB5_78: + WORD $0x294d; BYTE $0xfe // subq %r15, %r14 + WORD $0x894c; BYTE $0xc8 // movq %r9, %rax + WORD $0xf748; BYTE $0xd0 // notq %rax + WORD $0x014c; BYTE $0xf0 // addq %r14, %rax + LONG $0x00458949 // movq %rax, (%r13) + WORD $0x294c; BYTE $0xd7 // subq %r10, %rdi + WORD $0x014c; BYTE $0xcf // addq %r9, %rdi WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax - LONG $0xffffcfe9; BYTE $0xff // jmp LBB8_81, $-49(%rip) - LONG $0x00000000; BYTE $0x00 // .p2align 4, 0x00 + LONG $0xffffd3e9; BYTE $0xff // jmp LBB5_77, $-45(%rip) -LCPI9_0: + // .p2align 4, 0x00 +LCPI6_0: QUAD $0x5c5c5c5c5c5c5c5c; QUAD $0x5c5c5c5c5c5c5c5c // .space 16, '\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' // .p2align 4, 0x90 @@ -2105,710 +1869,681 @@ _unquote: WORD $0x5541 // pushq %r13 WORD $0x5441 // pushq %r12 BYTE $0x53 // pushq %rbx - LONG $0x48ec8348 // subq $72, %rsp + LONG $0x28ec8348 // subq $40, %rsp WORD $0x8548; BYTE $0xf6 // testq %rsi, %rsi - LONG $0x062b840f; WORD $0x0000 // je LBB9_1, $1579(%rip) - LONG $0xd04d8948 // movq %rcx, $-48(%rbp) + LONG $0x066f840f; WORD $0x0000 // je LBB6_81, $1647(%rip) + WORD $0x8949; BYTE $0xf3 // movq %rsi, %r11 + LONG $0xc84d8948 // movq %rcx, $-56(%rbp) + WORD $0x894c; BYTE $0xc0 // movq %r8, %rax + LONG $0xb845894c // movq %r8, $-72(%rbp) WORD $0x8945; BYTE $0xc2 // movl %r8d, %r10d LONG $0x01e28341 // andl $1, %r10d - LONG $0x84258d4c; WORD $0x00e1; BYTE $0x00 // leaq $57732(%rip), %r12 /* __UnquoteTab(%rip) */ - QUAD $0xffffffbc0d6f0f66 // movdqa $-68(%rip), %xmm1 /* LCPI9_0(%rip) */ - WORD $0x8949; BYTE $0xff // movq %rdi, %r15 + LONG $0x5a058d4c; WORD $0x00ec; BYTE $0x00 // leaq $60506(%rip), %r8 /* __UnquoteTab(%rip) */ + QUAD $0xffffffb2056f0f66 // movdqa $-78(%rip), %xmm0 /* LCPI6_0(%rip) */ + WORD $0x8949; BYTE $0xf9 // movq %rdi, %r9 WORD $0x8949; BYTE $0xf5 // movq %rsi, %r13 - WORD $0x8949; BYTE $0xd6 // movq %rdx, %r14 - LONG $0xb845894c // movq %r8, $-72(%rbp) - -LBB9_4: - LONG $0x5c3f8041 // cmpb $92, (%r15) - LONG $0x0015850f; WORD $0x0000 // jne LBB9_6, $21(%rip) - WORD $0x3145; BYTE $0xdb // xorl %r11d, %r11d - LONG $0x0000cde9; BYTE $0x00 // jmp LBB9_18, $205(%rip) - QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 + WORD $0x8948; BYTE $0xd0 // movq %rdx, %rax -LBB9_6: - WORD $0x894d; BYTE $0xe9 // movq %r13, %r9 - WORD $0x894c; BYTE $0xf1 // movq %r14, %rcx - WORD $0x894d; BYTE $0xfb // movq %r15, %r11 - LONG $0x10fd8349 // cmpq $16, %r13 - LONG $0x00458c0f; WORD $0x0000 // jl LBB9_12, $69(%rip) - WORD $0xc931 // xorl %ecx, %ecx - WORD $0x894c; BYTE $0xe8 // movq %r13, %rax +LBB6_2: + LONG $0x5c398041 // cmpb $92, (%r9) + LONG $0x000f850f; WORD $0x0000 // jne LBB6_4, $15(%rip) + WORD $0xf631 // xorl %esi, %esi + LONG $0x0000c8e9; BYTE $0x00 // jmp LBB6_13, $200(%rip) QUAD $0x9090909090909090 // .p2align 4, 0x90 -LBB9_8: - LONG $0x6f0f41f3; WORD $0x0f04 // movdqu (%r15,%rcx), %xmm0 - LONG $0x7f0f41f3; WORD $0x0e04 // movdqu %xmm0, (%r14,%rcx) - LONG $0xc1740f66 // pcmpeqb %xmm1, %xmm0 - LONG $0xd8d70f66 // pmovmskb %xmm0, %ebx - WORD $0xdb85 // testl %ebx, %ebx - LONG $0x006b850f; WORD $0x0000 // jne LBB9_9, $107(%rip) - LONG $0xf0488d4c // leaq $-16(%rax), %r9 +LBB6_4: + WORD $0x894d; BYTE $0xee // movq %r13, %r14 + WORD $0x8948; BYTE $0xc1 // movq %rax, %rcx + WORD $0x894d; BYTE $0xcf // movq %r9, %r15 + LONG $0x10fd8349 // cmpq $16, %r13 + LONG $0x00408c0f; WORD $0x0000 // jl LBB6_7, $64(%rip) + QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB6_5: + LONG $0x6f0f41f3; BYTE $0x0f // movdqu (%r15), %xmm1 + LONG $0x097f0ff3 // movdqu %xmm1, (%rcx) + LONG $0xc8740f66 // pcmpeqb %xmm0, %xmm1 + LONG $0xf1d70f66 // pmovmskb %xmm1, %esi + WORD $0x8566; BYTE $0xf6 // testw %si, %si + LONG $0x0060850f; WORD $0x0000 // jne LBB6_12, $96(%rip) + LONG $0x10c78349 // addq $16, %r15 LONG $0x10c18348 // addq $16, %rcx - LONG $0x1ff88348 // cmpq $31, %rax - WORD $0x894c; BYTE $0xc8 // movq %r9, %rax - LONG $0xffcf870f; WORD $0xffff // ja LBB9_8, $-49(%rip) - LONG $0x0f1c8d4d // leaq (%r15,%rcx), %r11 - WORD $0x014c; BYTE $0xf1 // addq %r14, %rcx + LONG $0xf0768d49 // leaq $-16(%r14), %rsi + LONG $0x1ffe8349 // cmpq $31, %r14 + WORD $0x8949; BYTE $0xf6 // movq %rsi, %r14 + LONG $0xffcd8f0f; WORD $0xffff // jg LBB6_5, $-51(%rip) -LBB9_12: - WORD $0x854d; BYTE $0xc9 // testq %r9, %r9 - LONG $0x058a840f; WORD $0x0000 // je LBB9_2, $1418(%rip) - WORD $0xc031 // xorl %eax, %eax - QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 +LBB6_7: + WORD $0x854d; BYTE $0xf6 // testq %r14, %r14 + LONG $0x05d3840f; WORD $0x0000 // je LBB6_82, $1491(%rip) + WORD $0xf631 // xorl %esi, %esi + WORD $0x9090 // .p2align 4, 0x90 -LBB9_14: - LONG $0x1cb60f41; BYTE $0x03 // movzbl (%r11,%rax), %ebx +LBB6_9: + LONG $0x1cb60f41; BYTE $0x37 // movzbl (%r15,%rsi), %ebx WORD $0xfb80; BYTE $0x5c // cmpb $92, %bl - LONG $0x0014840f; WORD $0x0000 // je LBB9_16, $20(%rip) - WORD $0x1c88; BYTE $0x01 // movb %bl, (%rcx,%rax) - WORD $0xff48; BYTE $0xc0 // incq %rax - WORD $0x3949; BYTE $0xc1 // cmpq %rax, %r9 - LONG $0xffe3850f; WORD $0xffff // jne LBB9_14, $-29(%rip) - LONG $0x000559e9; BYTE $0x00 // jmp LBB9_2, $1369(%rip) - -LBB9_16: - WORD $0x294d; BYTE $0xfb // subq %r15, %r11 - WORD $0x0149; BYTE $0xc3 // addq %rax, %r11 - LONG $0xfffb8349 // cmpq $-1, %r11 - LONG $0x001e850f; WORD $0x0000 // jne LBB9_18, $30(%rip) - LONG $0x000544e9; BYTE $0x00 // jmp LBB9_2, $1348(%rip) - -LBB9_9: - LONG $0xc3bc0f66 // bsfw %bx, %ax - LONG $0xd8b70f44 // movzwl %ax, %r11d - WORD $0x0149; BYTE $0xcb // addq %rcx, %r11 - LONG $0xfffb8349 // cmpq $-1, %r11 - LONG $0x052f840f; WORD $0x0000 // je LBB9_2, $1327(%rip) - LONG $0x90909090 // .p2align 4, 0x90 + LONG $0x0014840f; WORD $0x0000 // je LBB6_11, $20(%rip) + WORD $0x1c88; BYTE $0x31 // movb %bl, (%rcx,%rsi) + WORD $0xff48; BYTE $0xc6 // incq %rsi + WORD $0x3949; BYTE $0xf6 // cmpq %rsi, %r14 + LONG $0xffe3850f; WORD $0xffff // jne LBB6_9, $-29(%rip) + LONG $0x0005ade9; BYTE $0x00 // jmp LBB6_82, $1453(%rip) -LBB9_18: - LONG $0x024b8d49 // leaq $2(%r11), %rcx +LBB6_11: + WORD $0x0149; BYTE $0xf7 // addq %rsi, %r15 + WORD $0x294d; BYTE $0xcf // subq %r9, %r15 + WORD $0x894c; BYTE $0xfe // movq %r15, %rsi + LONG $0xfffe8348 // cmpq $-1, %rsi + LONG $0x002b850f; WORD $0x0000 // jne LBB6_13, $43(%rip) + LONG $0x000595e9; BYTE $0x00 // jmp LBB6_82, $1429(%rip) + +LBB6_12: + WORD $0xb70f; BYTE $0xce // movzwl %si, %ecx + WORD $0x294d; BYTE $0xcf // subq %r9, %r15 + LONG $0xf1bc0f48 // bsfq %rcx, %rsi + WORD $0x014c; BYTE $0xfe // addq %r15, %rsi + LONG $0xfffe8348 // cmpq $-1, %rsi + LONG $0x057e840f; WORD $0x0000 // je LBB6_82, $1406(%rip) + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB6_13: + LONG $0x024e8d48 // leaq $2(%rsi), %rcx WORD $0x2949; BYTE $0xcd // subq %rcx, %r13 - LONG $0x05ea880f; WORD $0x0000 // js LBB9_19, $1514(%rip) - WORD $0x014d; BYTE $0xdf // addq %r11, %r15 - LONG $0x02c78349 // addq $2, %r15 + LONG $0x075b880f; WORD $0x0000 // js LBB6_111, $1883(%rip) + LONG $0x314c8d4d; BYTE $0x02 // leaq $2(%r9,%rsi), %r9 WORD $0x854d; BYTE $0xd2 // testq %r10, %r10 - LONG $0x0251850f; WORD $0x0000 // jne LBB9_21, $593(%rip) - -LBB9_32: - WORD $0x014d; BYTE $0xde // addq %r11, %r14 - LONG $0x47b60f41; BYTE $0xff // movzbl $-1(%r15), %eax - LONG $0x04b60f42; BYTE $0x20 // movzbl (%rax,%r12), %eax - LONG $0x0000ff3d; BYTE $0x00 // cmpl $255, %eax - LONG $0x002b840f; WORD $0x0000 // je LBB9_38, $43(%rip) - WORD $0xc085 // testl %eax, %eax - LONG $0x05d5840f; WORD $0x0000 // je LBB9_34, $1493(%rip) - WORD $0x8841; BYTE $0x06 // movb %al, (%r14) - WORD $0xff49; BYTE $0xc6 // incq %r14 - WORD $0x854d; BYTE $0xed // testq %r13, %r13 - LONG $0xfed5850f; WORD $0xffff // jne LBB9_4, $-299(%rip) - LONG $0x0005b9e9; BYTE $0x00 // jmp LBB9_37, $1465(%rip) - QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + LONG $0x03f5850f; WORD $0x0000 // jne LBB6_58, $1013(%rip) + +LBB6_15: + WORD $0x0148; BYTE $0xf0 // addq %rsi, %rax + LONG $0x49b60f41; BYTE $0xff // movzbl $-1(%r9), %ecx + LONG $0x010c8a42 // movb (%rcx,%r8), %cl + WORD $0xf980; BYTE $0xff // cmpb $-1, %cl + LONG $0x0020840f; WORD $0x0000 // je LBB6_18, $32(%rip) + WORD $0xc984 // testb %cl, %cl + LONG $0x0600840f; WORD $0x0000 // je LBB6_93, $1536(%rip) + WORD $0x0888 // movb %cl, (%rax) + WORD $0xff48; BYTE $0xc0 // incq %rax + LONG $0x0003c0e9; BYTE $0x00 // jmp LBB6_57, $960(%rip) + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 -LBB9_38: +LBB6_18: LONG $0x03fd8349 // cmpq $3, %r13 - LONG $0x058d860f; WORD $0x0000 // jbe LBB9_19, $1421(%rip) - WORD $0x8b41; BYTE $0x1f // movl (%r15), %ebx - WORD $0xd989 // movl %ebx, %ecx + LONG $0x070e8e0f; WORD $0x0000 // jle LBB6_111, $1806(%rip) + WORD $0x8b41; BYTE $0x31 // movl (%r9), %esi + WORD $0xf189 // movl %esi, %ecx WORD $0xd1f7 // notl %ecx - LONG $0xcfd0838d; WORD $0xcfcf // leal $-808464432(%rbx), %eax + LONG $0xcfd09e8d; WORD $0xcfcf // leal $-808464432(%rsi), %ebx LONG $0x8080e181; WORD $0x8080 // andl $-2139062144, %ecx - WORD $0xc185 // testl %eax, %ecx - LONG $0x04be850f; WORD $0x0000 // jne LBB9_43, $1214(%rip) - LONG $0x1919838d; WORD $0x1919 // leal $421075225(%rbx), %eax - WORD $0xd809 // orl %ebx, %eax - LONG $0x808080a9; BYTE $0x80 // testl $-2139062144, %eax - LONG $0x04ab850f; WORD $0x0000 // jne LBB9_43, $1195(%rip) - WORD $0xd889 // movl %ebx, %eax - LONG $0x7f7f7f25; BYTE $0x7f // andl $2139062143, %eax - LONG $0xc0c0bb41; WORD $0xc0c0 // movl $-1061109568, %r11d - WORD $0x2941; BYTE $0xc3 // subl %eax, %r11d - LONG $0x46888d44; WORD $0x4646; BYTE $0x46 // leal $1179010630(%rax), %r9d - WORD $0x2141; BYTE $0xcb // andl %ecx, %r11d - WORD $0x8545; BYTE $0xcb // testl %r9d, %r11d - LONG $0x0488850f; WORD $0x0000 // jne LBB9_43, $1160(%rip) - LONG $0xe0e0b941; WORD $0xe0e0 // movl $-522133280, %r9d - WORD $0x2941; BYTE $0xc1 // subl %eax, %r9d - LONG $0x39393905; BYTE $0x39 // addl $960051513, %eax - WORD $0x2144; BYTE $0xc9 // andl %r9d, %ecx - WORD $0xc185 // testl %eax, %ecx - LONG $0x046f850f; WORD $0x0000 // jne LBB9_43, $1135(%rip) - WORD $0xcb0f // bswapl %ebx - WORD $0xd989 // movl %ebx, %ecx - WORD $0xd1f7 // notl %ecx + WORD $0xd985 // testl %ebx, %ecx + LONG $0x050f850f; WORD $0x0000 // jne LBB6_84, $1295(%rip) + LONG $0x19199e8d; WORD $0x1919 // leal $421075225(%rsi), %ebx + WORD $0xf309 // orl %esi, %ebx + LONG $0x8080c3f7; WORD $0x8080 // testl $-2139062144, %ebx + LONG $0x04fb850f; WORD $0x0000 // jne LBB6_84, $1275(%rip) + WORD $0xf389 // movl %esi, %ebx + LONG $0x7f7fe381; WORD $0x7f7f // andl $2139062143, %ebx + LONG $0xc0c0be41; WORD $0xc0c0 // movl $-1061109568, %r14d + WORD $0x2941; BYTE $0xde // subl %ebx, %r14d + LONG $0x46bb8d44; WORD $0x4646; BYTE $0x46 // leal $1179010630(%rbx), %r15d + WORD $0x2141; BYTE $0xce // andl %ecx, %r14d + WORD $0x8545; BYTE $0xfe // testl %r15d, %r14d + LONG $0x04d7850f; WORD $0x0000 // jne LBB6_84, $1239(%rip) + LONG $0xe0e0be41; WORD $0xe0e0 // movl $-522133280, %r14d + WORD $0x2941; BYTE $0xde // subl %ebx, %r14d + LONG $0x3939c381; WORD $0x3939 // addl $960051513, %ebx + WORD $0x2144; BYTE $0xf1 // andl %r14d, %ecx + WORD $0xd985 // testl %ebx, %ecx + LONG $0x04bd850f; WORD $0x0000 // jne LBB6_84, $1213(%rip) + WORD $0xce0f // bswapl %esi + WORD $0xf189 // movl %esi, %ecx WORD $0xe9c1; BYTE $0x04 // shrl $4, %ecx + WORD $0xd1f7 // notl %ecx LONG $0x0101e181; WORD $0x0101 // andl $16843009, %ecx WORD $0x0c8d; BYTE $0xc9 // leal (%rcx,%rcx,8), %ecx - LONG $0x0f0fe381; WORD $0x0f0f // andl $252645135, %ebx - WORD $0xcb01 // addl %ecx, %ebx - WORD $0xd989 // movl %ebx, %ecx + LONG $0x0f0fe681; WORD $0x0f0f // andl $252645135, %esi + WORD $0xce01 // addl %ecx, %esi + WORD $0xf189 // movl %esi, %ecx WORD $0xe9c1; BYTE $0x04 // shrl $4, %ecx - WORD $0xd909 // orl %ebx, %ecx - WORD $0xb60f; BYTE $0xd9 // movzbl %cl, %ebx + WORD $0xf109 // orl %esi, %ecx + LONG $0xf9b60f44 // movzbl %cl, %r15d WORD $0xe9c1; BYTE $0x08 // shrl $8, %ecx LONG $0xff00e181; WORD $0x0000 // andl $65280, %ecx - WORD $0xcb09 // orl %ecx, %ebx - LONG $0x044f8d4d // leaq $4(%r15), %r9 - LONG $0xfc4d8d49 // leaq $-4(%r13), %rcx - LONG $0x0080fb81; WORD $0x0000 // cmpl $128, %ebx - LONG $0x01a7820f; WORD $0x0000 // jb LBB9_54, $423(%rip) - LONG $0x02c0f641 // testb $2, %r8b - LONG $0x01ae840f; WORD $0x0000 // je LBB9_65, $430(%rip) - WORD $0x894d; BYTE $0xcf // movq %r9, %r15 - WORD $0x8941; BYTE $0xdc // movl %ebx, %r12d - WORD $0x8949; BYTE $0xcd // movq %rcx, %r13 - -LBB9_59: - LONG $0xfffc8141; WORD $0x0007; BYTE $0x00 // cmpl $2047, %r12d - LONG $0x028b860f; WORD $0x0000 // jbe LBB9_67, $651(%rip) - QUAD $0xffff200024848d41 // leal $-57344(%r12), %eax - LONG $0xfff7ff3d; BYTE $0xff // cmpl $-2049, %eax - LONG $0x01b6860f; WORD $0x0000 // jbe LBB9_70, $438(%rip) + WORD $0x0941; BYTE $0xcf // orl %ecx, %r15d + LONG $0xfc758d4d // leaq $-4(%r13), %r14 + LONG $0x80ff8141; WORD $0x0000; BYTE $0x00 // cmpl $128, %r15d + LONG $0x0356820f; WORD $0x0000 // jb LBB6_66, $854(%rip) + WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d WORD $0x854d; BYTE $0xd2 // testq %r10, %r10 - LONG $0xc07d8948 // movq %rdi, $-64(%rbp) + LONG $0x014b850f; WORD $0x0000 // jne LBB6_38, $331(%rip) + +LBB6_25: + LONG $0x00ff8141; WORD $0x0008; BYTE $0x00 // cmpl $2048, %r15d + LONG $0x034c820f; WORD $0x0000 // jb LBB6_68, $844(%rip) + WORD $0x8944; BYTE $0xf9 // movl %r15d, %ecx + LONG $0xf800e181; WORD $0xffff // andl $-2048, %ecx + LONG $0xd800f981; WORD $0x0000 // cmpl $55296, %ecx + LONG $0x0299850f; WORD $0x0000 // jne LBB6_54, $665(%rip) + LONG $0xffff8141; WORD $0x00db; BYTE $0x00 // cmpl $56319, %r15d + LONG $0x034f870f; WORD $0x0000 // ja LBB6_69, $847(%rip) + LONG $0x06fe8349 // cmpq $6, %r14 + LONG $0x03458c0f; WORD $0x0000 // jl LBB6_69, $837(%rip) + LONG $0x217c8043; WORD $0x5c04 // cmpb $92, $4(%r9,%r12) + LONG $0x0339850f; WORD $0x0000 // jne LBB6_69, $825(%rip) + LONG $0x217c8043; WORD $0x7505 // cmpb $117, $5(%r9,%r12) + LONG $0x032d850f; WORD $0x0000 // jne LBB6_69, $813(%rip) + LONG $0x21748b43; BYTE $0x06 // movl $6(%r9,%r12), %esi + WORD $0xf189 // movl %esi, %ecx + WORD $0xd1f7 // notl %ecx + LONG $0xcfd09e8d; WORD $0xcfcf // leal $-808464432(%rsi), %ebx + LONG $0x8080e181; WORD $0x8080 // andl $-2139062144, %ecx + WORD $0xd985 // testl %ebx, %ecx + LONG $0x04d9850f; WORD $0x0000 // jne LBB6_95, $1241(%rip) + LONG $0x19199e8d; WORD $0x1919 // leal $421075225(%rsi), %ebx + WORD $0xf309 // orl %esi, %ebx + LONG $0x8080c3f7; WORD $0x8080 // testl $-2139062144, %ebx + LONG $0x04c5850f; WORD $0x0000 // jne LBB6_95, $1221(%rip) + WORD $0xf389 // movl %esi, %ebx + LONG $0x7f7fe381; WORD $0x7f7f // andl $2139062143, %ebx + LONG $0xc0d445c7; WORD $0xc0c0; BYTE $0xc0 // movl $-1061109568, $-44(%rbp) + WORD $0x5d29; BYTE $0xd4 // subl %ebx, $-44(%rbp) LONG $0xb0758948 // movq %rsi, $-80(%rbp) - LONG $0x00ca850f; WORD $0x0000 // jne LBB9_62, $202(%rip) - LONG $0xa855894c // movq %r10, $-88(%rbp) - LONG $0xa0558948 // movq %rdx, $-96(%rbp) - LONG $0x06fd8349 // cmpq $6, %r13 - LONG $0x00e38c0f; WORD $0x0000 // jl LBB9_94, $227(%rip) - -LBB9_91: - LONG $0xfffc8141; WORD $0x00db; BYTE $0x00 // cmpl $56319, %r12d - LONG $0x00d6870f; WORD $0x0000 // ja LBB9_94, $214(%rip) - LONG $0x5c3f8041 // cmpb $92, (%r15) - LONG $0x00cc850f; WORD $0x0000 // jne LBB9_94, $204(%rip) - LONG $0x017f8041; BYTE $0x75 // cmpb $117, $1(%r15) - LONG $0x00c1850f; WORD $0x0000 // jne LBB9_94, $193(%rip) - LONG $0x025f8b41 // movl $2(%r15), %ebx - WORD $0xdf89 // movl %ebx, %edi - LONG $0x0005e6e8; BYTE $0x00 // callq _unhex16_is, $1510(%rip) - WORD $0xc084 // testb %al, %al - LONG $0x04d2840f; WORD $0x0000 // je LBB9_100, $1234(%rip) - WORD $0xcb0f // bswapl %ebx - WORD $0xd889 // movl %ebx, %eax - WORD $0xd0f7 // notl %eax - WORD $0xe8c1; BYTE $0x04 // shrl $4, %eax - LONG $0x01010125; BYTE $0x01 // andl $16843009, %eax - WORD $0x048d; BYTE $0xc0 // leal (%rax,%rax,8), %eax - LONG $0x0f0fe381; WORD $0x0f0f // andl $252645135, %ebx - WORD $0xc301 // addl %eax, %ebx - WORD $0xd889 // movl %ebx, %eax - WORD $0xe8c1; BYTE $0x04 // shrl $4, %eax - WORD $0xd809 // orl %ebx, %eax - WORD $0xb60f; BYTE $0xc8 // movzbl %al, %ecx - WORD $0xe8c1; BYTE $0x08 // shrl $8, %eax - LONG $0x00ff0025; BYTE $0x00 // andl $65280, %eax - WORD $0x1c8d; BYTE $0x08 // leal (%rax,%rcx), %ebx - LONG $0x06c78349 // addq $6, %r15 - LONG $0xfac58349 // addq $-6, %r13 - WORD $0xc801 // addl %ecx, %eax - LONG $0xff200005; BYTE $0xff // addl $-57344, %eax - LONG $0xfffbff3d; BYTE $0xff // cmpl $-1025, %eax - LONG $0xc07d8b48 // movq $-64(%rbp), %rdi - LONG $0xa0558b48 // movq $-96(%rbp), %rdx + LONG $0x4646b38d; WORD $0x4646 // leal $1179010630(%rbx), %esi + WORD $0x7589; BYTE $0xc4 // movl %esi, $-60(%rbp) + WORD $0x4d21; BYTE $0xd4 // andl %ecx, $-44(%rbp) + WORD $0x758b; BYTE $0xc4 // movl $-60(%rbp), %esi + WORD $0x7585; BYTE $0xd4 // testl %esi, $-44(%rbp) LONG $0xb0758b48 // movq $-80(%rbp), %rsi - QUAD $0xfffffcd80d6f0f66 // movdqa $-808(%rip), %xmm1 /* LCPI9_0(%rip) */ - LONG $0x0144870f; WORD $0x0000 // ja LBB9_110, $324(%rip) - LONG $0x06c74166; WORD $0xbfef // movw $-16401, (%r14) - LONG $0x0246c641; BYTE $0xbd // movb $-67, $2(%r14) - LONG $0x03c68349 // addq $3, %r14 - WORD $0x8941; BYTE $0xdc // movl %ebx, %r12d + LONG $0x0493850f; WORD $0x0000 // jne LBB6_95, $1171(%rip) + LONG $0xe0d445c7; WORD $0xe0e0; BYTE $0xe0 // movl $-522133280, $-44(%rbp) + WORD $0x5d29; BYTE $0xd4 // subl %ebx, $-44(%rbp) + LONG $0x3939c381; WORD $0x3939 // addl $960051513, %ebx + WORD $0x4d23; BYTE $0xd4 // andl $-44(%rbp), %ecx + WORD $0xd985 // testl %ebx, %ecx + LONG $0x0478850f; WORD $0x0000 // jne LBB6_95, $1144(%rip) + WORD $0xce0f // bswapl %esi + WORD $0xf189 // movl %esi, %ecx + WORD $0xe9c1; BYTE $0x04 // shrl $4, %ecx + WORD $0xd1f7 // notl %ecx + LONG $0x0101e181; WORD $0x0101 // andl $16843009, %ecx + WORD $0x0c8d; BYTE $0xc9 // leal (%rcx,%rcx,8), %ecx + LONG $0x0f0fe681; WORD $0x0f0f // andl $252645135, %esi + WORD $0xce01 // addl %ecx, %esi + WORD $0xf189 // movl %esi, %ecx + WORD $0xe9c1; BYTE $0x04 // shrl $4, %ecx + WORD $0xf109 // orl %esi, %ecx + WORD $0xce89 // movl %ecx, %esi + WORD $0xeec1; BYTE $0x08 // shrl $8, %esi + LONG $0xff00e681; WORD $0x0000 // andl $65280, %esi + WORD $0xb60f; BYTE $0xd9 // movzbl %cl, %ebx + WORD $0xf309 // orl %esi, %ebx + LONG $0x0000e181; WORD $0x00fc // andl $16515072, %ecx + LONG $0x0000f981; WORD $0x00dc // cmpl $14417920, %ecx + LONG $0x02b1840f; WORD $0x0000 // je LBB6_75, $689(%rip) + LONG $0x02b845f6 // testb $2, $-72(%rbp) + LONG $0x0564840f; WORD $0x0000 // je LBB6_114, $1380(%rip) + LONG $0xfac68349 // addq $-6, %r14 + LONG $0xef00c766; BYTE $0xbf // movw $-16401, (%rax) + LONG $0xbd0240c6 // movb $-67, $2(%rax) + LONG $0x03c08348 // addq $3, %rax + LONG $0x06c48349 // addq $6, %r12 + WORD $0x8941; BYTE $0xdf // movl %ebx, %r15d + WORD $0xfb83; BYTE $0x7f // cmpl $127, %ebx + LONG $0xfec3870f; WORD $0xffff // ja LBB6_25, $-317(%rip) + LONG $0x00015ee9; BYTE $0x00 // jmp LBB6_53, $350(%rip) + QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB6_38: + LONG $0x00ff8141; WORD $0x0008; BYTE $0x00 // cmpl $2048, %r15d + LONG $0x0201820f; WORD $0x0000 // jb LBB6_68, $513(%rip) + WORD $0x8944; BYTE $0xf9 // movl %r15d, %ecx + LONG $0xf800e181; WORD $0xffff // andl $-2048, %ecx + LONG $0xd800f981; WORD $0x0000 // cmpl $55296, %ecx + LONG $0x014e850f; WORD $0x0000 // jne LBB6_54, $334(%rip) + WORD $0x854d; BYTE $0xf6 // testq %r14, %r14 + LONG $0x04be8e0f; WORD $0x0000 // jle LBB6_108, $1214(%rip) + LONG $0x217c8043; WORD $0x5c04 // cmpb $92, $4(%r9,%r12) + LONG $0x022d850f; WORD $0x0000 // jne LBB6_73, $557(%rip) + LONG $0xffff8141; WORD $0x00db; BYTE $0x00 // cmpl $56319, %r15d + LONG $0x01f9870f; WORD $0x0000 // ja LBB6_70, $505(%rip) + LONG $0x07fe8349 // cmpq $7, %r14 + LONG $0x01ef8c0f; WORD $0x0000 // jl LBB6_70, $495(%rip) + LONG $0x217c8043; WORD $0x5c05 // cmpb $92, $5(%r9,%r12) + LONG $0x01e3850f; WORD $0x0000 // jne LBB6_70, $483(%rip) + LONG $0x217c8043; WORD $0x7506 // cmpb $117, $6(%r9,%r12) + LONG $0x01d7850f; WORD $0x0000 // jne LBB6_70, $471(%rip) + LONG $0x21748b43; BYTE $0x07 // movl $7(%r9,%r12), %esi + WORD $0xf189 // movl %esi, %ecx + WORD $0xd1f7 // notl %ecx + LONG $0xcfd09e8d; WORD $0xcfcf // leal $-808464432(%rsi), %ebx + LONG $0x8080e181; WORD $0x8080 // andl $-2139062144, %ecx + WORD $0xd985 // testl %ebx, %ecx + LONG $0x0383850f; WORD $0x0000 // jne LBB6_96, $899(%rip) + LONG $0x19199e8d; WORD $0x1919 // leal $421075225(%rsi), %ebx + WORD $0xf309 // orl %esi, %ebx + LONG $0x8080c3f7; WORD $0x8080 // testl $-2139062144, %ebx + LONG $0x036f850f; WORD $0x0000 // jne LBB6_96, $879(%rip) + WORD $0xf389 // movl %esi, %ebx + LONG $0x7f7fe381; WORD $0x7f7f // andl $2139062143, %ebx + LONG $0xc0d445c7; WORD $0xc0c0; BYTE $0xc0 // movl $-1061109568, $-44(%rbp) + WORD $0x5d29; BYTE $0xd4 // subl %ebx, $-44(%rbp) + LONG $0xb0758948 // movq %rsi, $-80(%rbp) + LONG $0x4646b38d; WORD $0x4646 // leal $1179010630(%rbx), %esi + WORD $0x7589; BYTE $0xc4 // movl %esi, $-60(%rbp) + WORD $0x4d21; BYTE $0xd4 // andl %ecx, $-44(%rbp) + WORD $0x758b; BYTE $0xc4 // movl $-60(%rbp), %esi + WORD $0x7585; BYTE $0xd4 // testl %esi, $-44(%rbp) + LONG $0xb0758b48 // movq $-80(%rbp), %rsi + LONG $0x033d850f; WORD $0x0000 // jne LBB6_96, $829(%rip) + LONG $0xe0d445c7; WORD $0xe0e0; BYTE $0xe0 // movl $-522133280, $-44(%rbp) + WORD $0x5d29; BYTE $0xd4 // subl %ebx, $-44(%rbp) + LONG $0x3939c381; WORD $0x3939 // addl $960051513, %ebx + WORD $0x4d23; BYTE $0xd4 // andl $-44(%rbp), %ecx + WORD $0xd985 // testl %ebx, %ecx + LONG $0x0322850f; WORD $0x0000 // jne LBB6_96, $802(%rip) + WORD $0xce0f // bswapl %esi + WORD $0xf189 // movl %esi, %ecx + WORD $0xe9c1; BYTE $0x04 // shrl $4, %ecx + WORD $0xd1f7 // notl %ecx + LONG $0x0101e181; WORD $0x0101 // andl $16843009, %ecx + WORD $0x0c8d; BYTE $0xc9 // leal (%rcx,%rcx,8), %ecx + LONG $0x0f0fe681; WORD $0x0f0f // andl $252645135, %esi + WORD $0xce01 // addl %ecx, %esi + WORD $0xf189 // movl %esi, %ecx + WORD $0xe9c1; BYTE $0x04 // shrl $4, %ecx + WORD $0xf109 // orl %esi, %ecx + WORD $0xce89 // movl %ecx, %esi + WORD $0xeec1; BYTE $0x08 // shrl $8, %esi + LONG $0xff00e681; WORD $0x0000 // andl $65280, %esi + WORD $0xb60f; BYTE $0xd9 // movzbl %cl, %ebx + WORD $0xf309 // orl %esi, %ebx + LONG $0x0000e181; WORD $0x00fc // andl $16515072, %ecx + LONG $0x0000f981; WORD $0x00dc // cmpl $14417920, %ecx + LONG $0x0162840f; WORD $0x0000 // je LBB6_76, $354(%rip) + LONG $0x02b845f6 // testb $2, $-72(%rbp) + LONG $0x040e840f; WORD $0x0000 // je LBB6_115, $1038(%rip) + LONG $0xf9c68349 // addq $-7, %r14 + LONG $0xef00c766; BYTE $0xbf // movw $-16401, (%rax) + LONG $0xbd0240c6 // movb $-67, $2(%rax) + LONG $0x03c08348 // addq $3, %rax + LONG $0x07c48349 // addq $7, %r12 + WORD $0x8941; BYTE $0xdf // movl %ebx, %r15d LONG $0x0080fb81; WORD $0x0000 // cmpl $128, %ebx - LONG $0xa8558b4c // movq $-88(%rbp), %r10 - LONG $0xff0a830f; WORD $0xffff // jae LBB9_59, $-246(%rip) - LONG $0x00009fe9; BYTE $0x00 // jmp LBB9_55, $159(%rip) + LONG $0xfeab830f; WORD $0xffff // jae LBB6_38, $-341(%rip) -LBB9_62: - WORD $0x854d; BYTE $0xed // testq %r13, %r13 - LONG $0x04218e0f; WORD $0x0000 // jle LBB9_63, $1057(%rip) - LONG $0x5c3f8041 // cmpb $92, (%r15) - LONG $0x026f850f; WORD $0x0000 // jne LBB9_96, $623(%rip) - WORD $0xff49; BYTE $0xcd // decq %r13 - WORD $0xff49; BYTE $0xc7 // incq %r15 - LONG $0xa855894c // movq %r10, $-88(%rbp) - LONG $0xa0558948 // movq %rdx, $-96(%rbp) - LONG $0x06fd8349 // cmpq $6, %r13 - LONG $0xff1d8d0f; WORD $0xffff // jge LBB9_91, $-227(%rip) +LBB6_53: + LONG $0x214c8d4f; BYTE $0x04 // leaq $4(%r9,%r12), %r9 + WORD $0x8941; BYTE $0xdf // movl %ebx, %r15d + LONG $0x0000a1e9; BYTE $0x00 // jmp LBB6_67, $161(%rip) + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 -LBB9_94: - LONG $0x02b845f6 // testb $2, $-72(%rbp) - LONG $0x02a9840f; WORD $0x0000 // je LBB9_77, $681(%rip) - LONG $0x06c74166; WORD $0xbfef // movw $-16401, (%r14) - LONG $0x0246c641; BYTE $0xbd // movb $-67, $2(%r14) - LONG $0x03c68349 // addq $3, %r14 - LONG $0x00011ae9; BYTE $0x00 // jmp LBB9_86, $282(%rip) +LBB6_54: + LONG $0x214c8d4f; BYTE $0x04 // leaq $4(%r9,%r12), %r9 + WORD $0x8944; BYTE $0xf9 // movl %r15d, %ecx + WORD $0xe9c1; BYTE $0x0c // shrl $12, %ecx + WORD $0xc980; BYTE $0xe0 // orb $-32, %cl + WORD $0x0888 // movb %cl, (%rax) + WORD $0x8944; BYTE $0xf9 // movl %r15d, %ecx + WORD $0xe9c1; BYTE $0x06 // shrl $6, %ecx + WORD $0xe180; BYTE $0x3f // andb $63, %cl + WORD $0xc980; BYTE $0x80 // orb $-128, %cl + WORD $0x4888; BYTE $0x01 // movb %cl, $1(%rax) + LONG $0x3fe78041 // andb $63, %r15b + LONG $0x80cf8041 // orb $-128, %r15b + LONG $0x02788844 // movb %r15b, $2(%rax) -LBB9_21: +LBB6_55: + LONG $0x03c08348 // addq $3, %rax + +LBB6_56: + WORD $0x894d; BYTE $0xf5 // movq %r14, %r13 + +LBB6_57: + WORD $0x854d; BYTE $0xed // testq %r13, %r13 + LONG $0xfb1c850f; WORD $0xffff // jne LBB6_2, $-1252(%rip) + LONG $0x000350e9; BYTE $0x00 // jmp LBB6_110, $848(%rip) + +LBB6_58: WORD $0x8545; BYTE $0xed // testl %r13d, %r13d - LONG $0x0380840f; WORD $0x0000 // je LBB9_19, $896(%rip) - LONG $0xff7f8041; BYTE $0x5c // cmpb $92, $-1(%r15) - LONG $0x03a9850f; WORD $0x0000 // jne LBB9_23, $937(%rip) - LONG $0x5c3f8041 // cmpb $92, (%r15) - LONG $0x0027850f; WORD $0x0000 // jne LBB9_31, $39(%rip) + LONG $0x034f840f; WORD $0x0000 // je LBB6_111, $847(%rip) + LONG $0xff798041; BYTE $0x5c // cmpb $92, $-1(%r9) + LONG $0x022d850f; WORD $0x0000 // jne LBB6_94, $557(%rip) + LONG $0x5c398041 // cmpb $92, (%r9) + LONG $0x0026850f; WORD $0x0000 // jne LBB6_65, $38(%rip) LONG $0x01fd8341 // cmpl $1, %r13d - LONG $0x03618e0f; WORD $0x0000 // jle LBB9_19, $865(%rip) - LONG $0x4fb60f41; BYTE $0x01 // movzbl $1(%r15), %ecx - WORD $0xf983; BYTE $0x22 // cmpl $34, %ecx - LONG $0x0009840f; WORD $0x0000 // je LBB9_30, $9(%rip) - WORD $0xf983; BYTE $0x5c // cmpl $92, %ecx - LONG $0x0397850f; WORD $0x0000 // jne LBB9_29, $919(%rip) - -LBB9_30: - WORD $0xff49; BYTE $0xc7 // incq %r15 + LONG $0x03308e0f; WORD $0x0000 // jle LBB6_111, $816(%rip) + LONG $0x01498a41 // movb $1(%r9), %cl + WORD $0xf980; BYTE $0x22 // cmpb $34, %cl + LONG $0x0009840f; WORD $0x0000 // je LBB6_64, $9(%rip) + WORD $0xf980; BYTE $0x5c // cmpb $92, %cl + LONG $0x02e2850f; WORD $0x0000 // jne LBB6_106, $738(%rip) + +LBB6_64: + WORD $0xff49; BYTE $0xc1 // incq %r9 WORD $0xff49; BYTE $0xcd // decq %r13 -LBB9_31: - WORD $0xff49; BYTE $0xc7 // incq %r15 +LBB6_65: + WORD $0xff49; BYTE $0xc1 // incq %r9 WORD $0xff49; BYTE $0xcd // decq %r13 - LONG $0xfffd5fe9; BYTE $0xff // jmp LBB9_32, $-673(%rip) - -LBB9_54: - WORD $0x8949; BYTE $0xcd // movq %rcx, %r13 - WORD $0x894d; BYTE $0xcf // movq %r9, %r15 - -LBB9_55: - WORD $0x8841; BYTE $0x1e // movb %bl, (%r14) - WORD $0xff49; BYTE $0xc6 // incq %r14 - LONG $0x00005ae9; BYTE $0x00 // jmp LBB9_56, $90(%rip) - -LBB9_65: - LONG $0x0800fb81; WORD $0x0000 // cmpl $2048, %ebx - LONG $0x00de820f; WORD $0x0000 // jb LBB9_66, $222(%rip) - LONG $0x2000838d; WORD $0xffff // leal $-57344(%rbx), %eax - LONG $0xfff8003d; BYTE $0xff // cmpl $-2048, %eax - LONG $0x00f6830f; WORD $0x0000 // jae LBB9_71, $246(%rip) - WORD $0x8949; BYTE $0xcd // movq %rcx, %r13 - WORD $0x8941; BYTE $0xdc // movl %ebx, %r12d - WORD $0x894d; BYTE $0xcf // movq %r9, %r15 - QUAD $0x9090909090909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + LONG $0xfffbbce9; BYTE $0xff // jmp LBB6_15, $-1092(%rip) -LBB9_70: - WORD $0x8944; BYTE $0xe0 // movl %r12d, %eax - WORD $0xe8c1; BYTE $0x0c // shrl $12, %eax - WORD $0xe00c // orb $-32, %al - WORD $0x8841; BYTE $0x06 // movb %al, (%r14) - WORD $0x8944; BYTE $0xe0 // movl %r12d, %eax - WORD $0xe8c1; BYTE $0x06 // shrl $6, %eax - WORD $0x3f24 // andb $63, %al - WORD $0x800c // orb $-128, %al - LONG $0x01468841 // movb %al, $1(%r14) - LONG $0x3fe48041 // andb $63, %r12b - LONG $0x80cc8041 // orb $-128, %r12b - LONG $0x02668845 // movb %r12b, $2(%r14) - LONG $0x03c68349 // addq $3, %r14 - -LBB9_56: - LONG $0xb8458b4c // movq $-72(%rbp), %r8 - LONG $0x5c258d4c; WORD $0x00dd; BYTE $0x00 // leaq $56668(%rip), %r12 /* __UnquoteTab(%rip) */ - WORD $0x854d; BYTE $0xed // testq %r13, %r13 - LONG $0xfbe4850f; WORD $0xffff // jne LBB9_4, $-1052(%rip) - LONG $0x0002c8e9; BYTE $0x00 // jmp LBB9_37, $712(%rip) - -LBB9_110: - WORD $0xd889 // movl %ebx, %eax - -LBB9_85: - LONG $0x0ae4c141 // shll $10, %r12d - WORD $0xc189 // movl %eax, %ecx - WORD $0x0144; BYTE $0xe1 // addl %r12d, %ecx - WORD $0x0144; BYTE $0xe0 // addl %r12d, %eax - LONG $0xa0240005; BYTE $0xfc // addl $-56613888, %eax - WORD $0xc289 // movl %eax, %edx - WORD $0xeac1; BYTE $0x12 // shrl $18, %edx - WORD $0xca80; BYTE $0xf0 // orb $-16, %dl - WORD $0x8841; BYTE $0x16 // movb %dl, (%r14) - WORD $0xc289 // movl %eax, %edx - WORD $0xeac1; BYTE $0x0c // shrl $12, %edx - WORD $0xe280; BYTE $0x3f // andb $63, %dl - WORD $0xca80; BYTE $0x80 // orb $-128, %dl - LONG $0x01568841 // movb %dl, $1(%r14) - WORD $0xe8c1; BYTE $0x06 // shrl $6, %eax - WORD $0x3f24 // andb $63, %al - WORD $0x800c // orb $-128, %al - LONG $0x02468841 // movb %al, $2(%r14) - WORD $0xe180; BYTE $0x3f // andb $63, %cl - WORD $0xc980; BYTE $0x80 // orb $-128, %cl - LONG $0x034e8841 // movb %cl, $3(%r14) - LONG $0x04c68349 // addq $4, %r14 +LBB6_66: + LONG $0x04c18349 // addq $4, %r9 -LBB9_86: - LONG $0xc07d8b48 // movq $-64(%rbp), %rdi - LONG $0xa0558b48 // movq $-96(%rbp), %rdx - LONG $0xa8558b4c // movq $-88(%rbp), %r10 - LONG $0xb0758b48 // movq $-80(%rbp), %rsi - LONG $0xb8458b4c // movq $-72(%rbp), %r8 - LONG $0xed258d4c; WORD $0x00dc; BYTE $0x00 // leaq $56557(%rip), %r12 /* __UnquoteTab(%rip) */ - QUAD $0xfffffb250d6f0f66 // movdqa $-1243(%rip), %xmm1 /* LCPI9_0(%rip) */ - WORD $0x854d; BYTE $0xed // testq %r13, %r13 - LONG $0xfb6d850f; WORD $0xffff // jne LBB9_4, $-1171(%rip) - LONG $0x000251e9; BYTE $0x00 // jmp LBB9_37, $593(%rip) - -LBB9_66: - WORD $0x8949; BYTE $0xcd // movq %rcx, %r13 - WORD $0x8941; BYTE $0xdc // movl %ebx, %r12d - WORD $0x894d; BYTE $0xcf // movq %r9, %r15 - -LBB9_67: - WORD $0x8944; BYTE $0xe0 // movl %r12d, %eax - WORD $0xe8c1; BYTE $0x06 // shrl $6, %eax - WORD $0xc00c // orb $-64, %al - WORD $0x8841; BYTE $0x06 // movb %al, (%r14) - LONG $0x3fe48041 // andb $63, %r12b - LONG $0x80cc8041 // orb $-128, %r12b - LONG $0x01668845 // movb %r12b, $1(%r14) - LONG $0x02c68349 // addq $2, %r14 - LONG $0xffff47e9; BYTE $0xff // jmp LBB9_56, $-185(%rip) - -LBB9_71: - WORD $0x8949; BYTE $0xdc // movq %rbx, %r12 - LONG $0x984d8948 // movq %rcx, $-104(%rbp) - LONG $0xc84d894c // movq %r9, $-56(%rbp) - LONG $0xb0758948 // movq %rsi, $-80(%rbp) - LONG $0xa0558948 // movq %rdx, $-96(%rbp) - LONG $0xc07d8948 // movq %rdi, $-64(%rbp) - LONG $0xa855894c // movq %r10, $-88(%rbp) - WORD $0x854d; BYTE $0xd2 // testq %r10, %r10 - LONG $0x00c7850f; WORD $0x0000 // jne LBB9_72, $199(%rip) - LONG $0x987d8348; BYTE $0x06 // cmpq $6, $-104(%rbp) - LONG $0x00ee820f; WORD $0x0000 // jb LBB9_76, $238(%rip) +LBB6_67: + WORD $0x8844; BYTE $0x38 // movb %r15b, (%rax) + WORD $0xff48; BYTE $0xc0 // incq %rax + LONG $0xffff91e9; BYTE $0xff // jmp LBB6_56, $-111(%rip) + +LBB6_68: + LONG $0x214c8d4f; BYTE $0x04 // leaq $4(%r9,%r12), %r9 + WORD $0x8944; BYTE $0xf9 // movl %r15d, %ecx + WORD $0xe9c1; BYTE $0x06 // shrl $6, %ecx + WORD $0xc980; BYTE $0xc0 // orb $-64, %cl + WORD $0x0888 // movb %cl, (%rax) + LONG $0x3fe78041 // andb $63, %r15b + LONG $0x80cf8041 // orb $-128, %r15b + LONG $0x01788844 // movb %r15b, $1(%rax) + LONG $0x02c08348 // addq $2, %rax + LONG $0xffff6ce9; BYTE $0xff // jmp LBB6_56, $-148(%rip) -LBB9_78: - LONG $0xfffc8141; WORD $0x00db; BYTE $0x00 // cmpl $56319, %r12d - LONG $0x00e1870f; WORD $0x0000 // ja LBB9_76, $225(%rip) - LONG $0xc8458b48 // movq $-56(%rbp), %rax - WORD $0x3880; BYTE $0x5c // cmpb $92, (%rax) - LONG $0x00d4850f; WORD $0x0000 // jne LBB9_76, $212(%rip) - LONG $0xc8458b48 // movq $-56(%rbp), %rax - LONG $0x75017880 // cmpb $117, $1(%rax) - LONG $0x00c6850f; WORD $0x0000 // jne LBB9_76, $198(%rip) - LONG $0xc8458b48 // movq $-56(%rbp), %rax - WORD $0x588b; BYTE $0x02 // movl $2(%rax), %ebx - WORD $0xdf89 // movl %ebx, %edi - LONG $0x000339e8; BYTE $0x00 // callq _unhex16_is, $825(%rip) - WORD $0xc084 // testb %al, %al - LONG $0x0221840f; WORD $0x0000 // je LBB9_82, $545(%rip) - WORD $0xcb0f // bswapl %ebx - WORD $0xd889 // movl %ebx, %eax - WORD $0xd0f7 // notl %eax - WORD $0xe8c1; BYTE $0x04 // shrl $4, %eax - LONG $0x01010125; BYTE $0x01 // andl $16843009, %eax - WORD $0x048d; BYTE $0xc0 // leal (%rax,%rax,8), %eax - LONG $0x0f0fe381; WORD $0x0f0f // andl $252645135, %ebx - WORD $0xc301 // addl %eax, %ebx - WORD $0xd889 // movl %ebx, %eax - WORD $0xe8c1; BYTE $0x04 // shrl $4, %eax - WORD $0xd809 // orl %ebx, %eax - WORD $0xb60f; BYTE $0xc8 // movzbl %al, %ecx - WORD $0xe8c1; BYTE $0x08 // shrl $8, %eax - LONG $0x00ff0025; BYTE $0x00 // andl $65280, %eax - LONG $0xc8458348; BYTE $0x06 // addq $6, $-56(%rbp) - WORD $0x148d; BYTE $0x08 // leal (%rax,%rcx), %edx - LONG $0x2000c281; WORD $0xffff // addl $-57344, %edx - LONG $0xfc00fa81; WORD $0xffff // cmpl $-1024, %edx - LONG $0x02ae820f; WORD $0x0000 // jb LBB9_98, $686(%rip) - WORD $0xc809 // orl %ecx, %eax - LONG $0x986d8b4c // movq $-104(%rbp), %r13 - LONG $0xfac58349 // addq $-6, %r13 - LONG $0xc87d8b4c // movq $-56(%rbp), %r15 - LONG $0xfffe9de9; BYTE $0xff // jmp LBB9_85, $-355(%rip) - -LBB9_96: +LBB6_69: + LONG $0x214c8d4f; BYTE $0x04 // leaq $4(%r9,%r12), %r9 + LONG $0x00000fe9; BYTE $0x00 // jmp LBB6_71, $15(%rip) + +LBB6_70: + LONG $0x214c8d4f; BYTE $0x05 // leaq $5(%r9,%r12), %r9 + WORD $0x294d; BYTE $0xe5 // subq %r12, %r13 + LONG $0xfbc58349 // addq $-5, %r13 + WORD $0x894d; BYTE $0xee // movq %r13, %r14 + +LBB6_71: LONG $0x02b845f6 // testb $2, $-72(%rbp) - LONG $0x028d840f; WORD $0x0000 // je LBB9_97, $653(%rip) - LONG $0x06c74166; WORD $0xbfef // movw $-16401, (%r14) - LONG $0x0246c641; BYTE $0xbd // movb $-67, $2(%r14) - LONG $0x03c68349 // addq $3, %r14 - LONG $0xc07d8b48 // movq $-64(%rbp), %rdi - LONG $0xb0758b48 // movq $-80(%rbp), %rsi - LONG $0xfffe5ce9; BYTE $0xff // jmp LBB9_56, $-420(%rip) + LONG $0x0308840f; WORD $0x0000 // je LBB6_117, $776(%rip) -LBB9_72: - LONG $0x05fd8349 // cmpq $5, %r13 - LONG $0x028a820f; WORD $0x0000 // jb LBB9_87, $650(%rip) - LONG $0xc8458b48 // movq $-56(%rbp), %rax - WORD $0x3880; BYTE $0x5c // cmpb $92, (%rax) - LONG $0x025e850f; WORD $0x0000 // jne LBB9_98, $606(%rip) - LONG $0xfbc58349 // addq $-5, %r13 - LONG $0x05c78349 // addq $5, %r15 - LONG $0x986d894c // movq %r13, $-104(%rbp) - LONG $0xc87d894c // movq %r15, $-56(%rbp) - LONG $0x987d8348; BYTE $0x06 // cmpq $6, $-104(%rbp) - LONG $0xff12830f; WORD $0xffff // jae LBB9_78, $-238(%rip) - -LBB9_76: - LONG $0xc87d8b4c // movq $-56(%rbp), %r15 - -LBB9_77: - LONG $0xa8458b48 // movq $-88(%rbp), %rax - LONG $0xc0450348 // addq $-64(%rbp), %rax - WORD $0x2949; BYTE $0xc7 // subq %rax, %r15 - LONG $0xfcc78349 // addq $-4, %r15 - LONG $0xd0458b48 // movq $-48(%rbp), %rax - WORD $0x894c; BYTE $0x38 // movq %r15, (%rax) - LONG $0xfcc6c749; WORD $0xffff; BYTE $0xff // movq $-4, %r14 - LONG $0x00000ce9; BYTE $0x00 // jmp LBB9_52, $12(%rip) +LBB6_72: + LONG $0xef00c766; BYTE $0xbf // movw $-16401, (%rax) + LONG $0xbd0240c6 // movb $-67, $2(%rax) + LONG $0xffff37e9; BYTE $0xff // jmp LBB6_55, $-201(%rip) -LBB9_1: +LBB6_73: + LONG $0x02b845f6 // testb $2, $-72(%rbp) + LONG $0x02fd840f; WORD $0x0000 // je LBB6_118, $765(%rip) + LONG $0x214c8d4f; BYTE $0x04 // leaq $4(%r9,%r12), %r9 + LONG $0xffffdee9; BYTE $0xff // jmp LBB6_72, $-34(%rip) + +LBB6_75: + LONG $0x214c8d4f; BYTE $0x0a // leaq $10(%r9,%r12), %r9 + WORD $0x294d; BYTE $0xe5 // subq %r12, %r13 + LONG $0xf6c58349 // addq $-10, %r13 + LONG $0x00000ce9; BYTE $0x00 // jmp LBB6_77, $12(%rip) + +LBB6_76: + LONG $0x214c8d4f; BYTE $0x0b // leaq $11(%r9,%r12), %r9 + WORD $0x294d; BYTE $0xe5 // subq %r12, %r13 + LONG $0xf5c58349 // addq $-11, %r13 + +LBB6_77: + LONG $0x0ae7c141 // shll $10, %r15d + QUAD $0xfca024001f8c8d41 // leal $-56613888(%r15,%rbx), %ecx + LONG $0x0000f981; WORD $0x0011 // cmpl $1114112, %ecx + LONG $0x001c820f; WORD $0x0000 // jb LBB6_80, $28(%rip) + LONG $0x02b845f6 // testb $2, $-72(%rbp) + LONG $0x0264840f; WORD $0x0000 // je LBB6_112, $612(%rip) + LONG $0xef00c766; BYTE $0xbf // movw $-16401, (%rax) + LONG $0xbd0240c6 // movb $-67, $2(%rax) + LONG $0x03c08348 // addq $3, %rax + LONG $0xfffed9e9; BYTE $0xff // jmp LBB6_57, $-295(%rip) + +LBB6_80: + WORD $0xce89 // movl %ecx, %esi + WORD $0xeec1; BYTE $0x12 // shrl $18, %esi + LONG $0xf0ce8040 // orb $-16, %sil + WORD $0x8840; BYTE $0x30 // movb %sil, (%rax) + WORD $0xce89 // movl %ecx, %esi + WORD $0xeec1; BYTE $0x0c // shrl $12, %esi + LONG $0x3fe68040 // andb $63, %sil + LONG $0x80ce8040 // orb $-128, %sil + LONG $0x01708840 // movb %sil, $1(%rax) + WORD $0xce89 // movl %ecx, %esi + WORD $0xeec1; BYTE $0x06 // shrl $6, %esi + LONG $0x3fe68040 // andb $63, %sil + LONG $0x80ce8040 // orb $-128, %sil + LONG $0x02708840 // movb %sil, $2(%rax) + WORD $0xe180; BYTE $0x3f // andb $63, %cl + WORD $0xc980; BYTE $0x80 // orb $-128, %cl + WORD $0x4888; BYTE $0x03 // movb %cl, $3(%rax) + LONG $0x04c08348 // addq $4, %rax + LONG $0xfffe99e9; BYTE $0xff // jmp LBB6_57, $-359(%rip) + +LBB6_81: WORD $0x3145; BYTE $0xed // xorl %r13d, %r13d - WORD $0x8949; BYTE $0xd6 // movq %rdx, %r14 + WORD $0x8948; BYTE $0xd0 // movq %rdx, %rax -LBB9_2: - WORD $0x014d; BYTE $0xee // addq %r13, %r14 - WORD $0x2949; BYTE $0xd6 // subq %rdx, %r14 +LBB6_82: + WORD $0x014c; BYTE $0xe8 // addq %r13, %rax + WORD $0x2948; BYTE $0xd0 // subq %rdx, %rax -LBB9_52: - WORD $0x894c; BYTE $0xf0 // movq %r14, %rax - LONG $0x48c48348 // addq $72, %rsp - BYTE $0x5b // popq %rbx - WORD $0x5c41 // popq %r12 - WORD $0x5d41 // popq %r13 - WORD $0x5e41 // popq %r14 - WORD $0x5f41 // popq %r15 - BYTE $0x5d // popq %rbp - BYTE $0xc3 // retq +LBB6_83: + LONG $0x28c48348 // addq $40, %rsp + BYTE $0x5b // popq %rbx + WORD $0x5c41 // popq %r12 + WORD $0x5d41 // popq %r13 + WORD $0x5e41 // popq %r14 + WORD $0x5f41 // popq %r15 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq -LBB9_43: - WORD $0x894c; BYTE $0xf8 // movq %r15, %rax - WORD $0x2948; BYTE $0xf8 // subq %rdi, %rax - LONG $0xd0758b48 // movq $-48(%rbp), %rsi - WORD $0x8948; BYTE $0x06 // movq %rax, (%rsi) - LONG $0x0fb60f41 // movzbl (%r15), %ecx - WORD $0x518d; BYTE $0xc6 // leal $-58(%rcx), %edx - LONG $0xfec6c749; WORD $0xffff; BYTE $0xff // movq $-2, %r14 - WORD $0xfa80; BYTE $0xf5 // cmpb $-11, %dl - LONG $0x000f870f; WORD $0x0000 // ja LBB9_45, $15(%rip) +LBB6_84: + WORD $0x894c; BYTE $0xca // movq %r9, %rdx + WORD $0x2948; BYTE $0xfa // subq %rdi, %rdx + LONG $0xc87d8b48 // movq $-56(%rbp), %rdi + WORD $0x8948; BYTE $0x17 // movq %rdx, (%rdi) + WORD $0x8a41; BYTE $0x09 // movb (%r9), %cl + WORD $0x718d; BYTE $0xd0 // leal $-48(%rcx), %esi + LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq $-2, %rax + LONG $0x0afe8040 // cmpb $10, %sil + LONG $0x000f820f; WORD $0x0000 // jb LBB6_86, $15(%rip) WORD $0xe180; BYTE $0xdf // andb $-33, %cl - WORD $0xc180; BYTE $0xb9 // addb $-71, %cl - WORD $0xf980; BYTE $0xfa // cmpb $-6, %cl - LONG $0xffbb820f; WORD $0xffff // jb LBB9_52, $-69(%rip) - -LBB9_45: - LONG $0x01488d48 // leaq $1(%rax), %rcx - WORD $0x8948; BYTE $0x0e // movq %rcx, (%rsi) - LONG $0x4fb60f41; BYTE $0x01 // movzbl $1(%r15), %ecx - WORD $0x518d; BYTE $0xc6 // leal $-58(%rcx), %edx - WORD $0xfa80; BYTE $0xf5 // cmpb $-11, %dl - LONG $0x000f870f; WORD $0x0000 // ja LBB9_47, $15(%rip) + WORD $0xc180; BYTE $0xbf // addb $-65, %cl + WORD $0xf980; BYTE $0x05 // cmpb $5, %cl + LONG $0xffbe870f; WORD $0xffff // ja LBB6_83, $-66(%rip) + +LBB6_86: + LONG $0x014a8d48 // leaq $1(%rdx), %rcx + WORD $0x8948; BYTE $0x0f // movq %rcx, (%rdi) + LONG $0x01498a41 // movb $1(%r9), %cl + WORD $0x718d; BYTE $0xd0 // leal $-48(%rcx), %esi + LONG $0x0afe8040 // cmpb $10, %sil + LONG $0x000f820f; WORD $0x0000 // jb LBB6_88, $15(%rip) WORD $0xe180; BYTE $0xdf // andb $-33, %cl - WORD $0xc180; BYTE $0xb9 // addb $-71, %cl - WORD $0xf980; BYTE $0xfa // cmpb $-6, %cl - LONG $0xff94820f; WORD $0xffff // jb LBB9_52, $-108(%rip) - -LBB9_47: - LONG $0x02488d48 // leaq $2(%rax), %rcx - WORD $0x8948; BYTE $0x0e // movq %rcx, (%rsi) - LONG $0x4fb60f41; BYTE $0x02 // movzbl $2(%r15), %ecx - WORD $0x518d; BYTE $0xc6 // leal $-58(%rcx), %edx - WORD $0xfa80; BYTE $0xf5 // cmpb $-11, %dl - LONG $0x000f870f; WORD $0x0000 // ja LBB9_49, $15(%rip) + WORD $0xc180; BYTE $0xbf // addb $-65, %cl + WORD $0xf980; BYTE $0x05 // cmpb $5, %cl + LONG $0xff97870f; WORD $0xffff // ja LBB6_83, $-105(%rip) + +LBB6_88: + LONG $0x024a8d48 // leaq $2(%rdx), %rcx + WORD $0x8948; BYTE $0x0f // movq %rcx, (%rdi) + LONG $0x02498a41 // movb $2(%r9), %cl + WORD $0x718d; BYTE $0xd0 // leal $-48(%rcx), %esi + LONG $0x0afe8040 // cmpb $10, %sil + LONG $0x000f820f; WORD $0x0000 // jb LBB6_90, $15(%rip) WORD $0xe180; BYTE $0xdf // andb $-33, %cl - WORD $0xc180; BYTE $0xb9 // addb $-71, %cl - WORD $0xf980; BYTE $0xfa // cmpb $-6, %cl - LONG $0xff6d820f; WORD $0xffff // jb LBB9_52, $-147(%rip) - -LBB9_49: - LONG $0x03488d48 // leaq $3(%rax), %rcx - WORD $0x8948; BYTE $0x0e // movq %rcx, (%rsi) - LONG $0x4fb60f41; BYTE $0x03 // movzbl $3(%r15), %ecx - WORD $0x518d; BYTE $0xc6 // leal $-58(%rcx), %edx - WORD $0xfa80; BYTE $0xf5 // cmpb $-11, %dl - LONG $0x000f870f; WORD $0x0000 // ja LBB9_51, $15(%rip) + WORD $0xc180; BYTE $0xbf // addb $-65, %cl + WORD $0xf980; BYTE $0x05 // cmpb $5, %cl + LONG $0xff70870f; WORD $0xffff // ja LBB6_83, $-144(%rip) + +LBB6_90: + LONG $0x034a8d48 // leaq $3(%rdx), %rcx + WORD $0x8948; BYTE $0x0f // movq %rcx, (%rdi) + LONG $0x03498a41 // movb $3(%r9), %cl + WORD $0x718d; BYTE $0xd0 // leal $-48(%rcx), %esi + LONG $0x0afe8040 // cmpb $10, %sil + LONG $0x000f820f; WORD $0x0000 // jb LBB6_92, $15(%rip) WORD $0xe180; BYTE $0xdf // andb $-33, %cl - WORD $0xc180; BYTE $0xb9 // addb $-71, %cl - WORD $0xf980; BYTE $0xfa // cmpb $-6, %cl - LONG $0xff46820f; WORD $0xffff // jb LBB9_52, $-186(%rip) - -LBB9_51: - LONG $0x04c08348 // addq $4, %rax - WORD $0x8948; BYTE $0x06 // movq %rax, (%rsi) - LONG $0xffff3ae9; BYTE $0xff // jmp LBB9_52, $-198(%rip) + WORD $0xc180; BYTE $0xbf // addb $-65, %cl + WORD $0xf980; BYTE $0x05 // cmpb $5, %cl + LONG $0xff49870f; WORD $0xffff // ja LBB6_83, $-183(%rip) -LBB9_19: - LONG $0xd0458b48 // movq $-48(%rbp), %rax - WORD $0x8948; BYTE $0x30 // movq %rsi, (%rax) - LONG $0xffc6c749; WORD $0xffff; BYTE $0xff // movq $-1, %r14 - LONG $0xffff27e9; BYTE $0xff // jmp LBB9_52, $-217(%rip) - -LBB9_37: - WORD $0x3145; BYTE $0xed // xorl %r13d, %r13d - LONG $0xffff19e9; BYTE $0xff // jmp LBB9_2, $-231(%rip) +LBB6_92: + LONG $0x04c28348 // addq $4, %rdx + WORD $0x8948; BYTE $0x17 // movq %rdx, (%rdi) + LONG $0xffff3de9; BYTE $0xff // jmp LBB6_83, $-195(%rip) -LBB9_34: +LBB6_93: WORD $0xf748; BYTE $0xd7 // notq %rdi - WORD $0x0149; BYTE $0xff // addq %rdi, %r15 - LONG $0xd0458b48 // movq $-48(%rbp), %rax - WORD $0x894c; BYTE $0x38 // movq %r15, (%rax) - LONG $0xfdc6c749; WORD $0xffff; BYTE $0xff // movq $-3, %r14 - LONG $0xffff06e9; BYTE $0xff // jmp LBB9_52, $-250(%rip) + WORD $0x0149; BYTE $0xf9 // addq %rdi, %r9 + LONG $0xc8458b48 // movq $-56(%rbp), %rax + WORD $0x894c; BYTE $0x08 // movq %r9, (%rax) + LONG $0xfdc0c748; WORD $0xffff; BYTE $0xff // movq $-3, %rax + LONG $0xffff24e9; BYTE $0xff // jmp LBB6_83, $-220(%rip) -LBB9_23: - WORD $0xf748; BYTE $0xd7 // notq %rdi - WORD $0x0149; BYTE $0xff // addq %rdi, %r15 +LBB6_94: + WORD $0xf748; BYTE $0xd7 // notq %rdi + WORD $0x0149; BYTE $0xf9 // addq %rdi, %r9 + LONG $0x0000dae9; BYTE $0x00 // jmp LBB6_107, $218(%rip) -LBB9_24: - LONG $0xd0458b48 // movq $-48(%rbp), %rax - WORD $0x894c; BYTE $0x38 // movq %r15, (%rax) - LONG $0xfec6c749; WORD $0xffff; BYTE $0xff // movq $-2, %r14 - LONG $0xfffeede9; BYTE $0xff // jmp LBB9_52, $-275(%rip) +LBB6_95: + LONG $0x21748d4b; BYTE $0x04 // leaq $4(%r9,%r12), %rsi + LONG $0x000005e9; BYTE $0x00 // jmp LBB6_97, $5(%rip) -LBB9_29: - WORD $0x2949; BYTE $0xff // subq %rdi, %r15 - WORD $0xff49; BYTE $0xc7 // incq %r15 - LONG $0xffffe2e9; BYTE $0xff // jmp LBB9_24, $-30(%rip) +LBB6_96: + LONG $0x21748d4b; BYTE $0x05 // leaq $5(%r9,%r12), %rsi -LBB9_63: - LONG $0x02b845f6 // testb $2, $-72(%rbp) - LONG $0x0108840f; WORD $0x0000 // je LBB9_87, $264(%rip) - LONG $0x06c74166; WORD $0xbfef // movw $-16401, (%r14) - LONG $0x0246c641; BYTE $0xbd // movb $-67, $2(%r14) - LONG $0x03c68349 // addq $3, %r14 - WORD $0x3145; BYTE $0xed // xorl %r13d, %r13d - LONG $0xfffebbe9; BYTE $0xff // jmp LBB9_2, $-325(%rip) - -LBB9_82: - LONG $0xc87d8b4c // movq $-56(%rbp), %r15 - -LBB9_100: - WORD $0x894c; BYTE $0xf8 // movq %r15, %rax - LONG $0xc0452b48 // subq $-64(%rbp), %rax - LONG $0x02c08348 // addq $2, %rax - LONG $0xd04d8b48 // movq $-48(%rbp), %rcx - WORD $0x8948; BYTE $0x01 // movq %rax, (%rcx) - LONG $0x4fb60f41; BYTE $0x02 // movzbl $2(%r15), %ecx - WORD $0x518d; BYTE $0xc6 // leal $-58(%rcx), %edx - LONG $0xfec6c749; WORD $0xffff; BYTE $0xff // movq $-2, %r14 - WORD $0xfa80; BYTE $0xf5 // cmpb $-11, %dl - LONG $0x000f870f; WORD $0x0000 // ja LBB9_102, $15(%rip) +LBB6_97: + WORD $0x8948; BYTE $0xf2 // movq %rsi, %rdx + WORD $0x2948; BYTE $0xfa // subq %rdi, %rdx + LONG $0x02c28348 // addq $2, %rdx + LONG $0xc8458b48 // movq $-56(%rbp), %rax + WORD $0x8948; BYTE $0x10 // movq %rdx, (%rax) + WORD $0x4e8a; BYTE $0x02 // movb $2(%rsi), %cl + WORD $0x798d; BYTE $0xd0 // leal $-48(%rcx), %edi + LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq $-2, %rax + LONG $0x0aff8040 // cmpb $10, %dil + LONG $0x000f820f; WORD $0x0000 // jb LBB6_99, $15(%rip) WORD $0xe180; BYTE $0xdf // andb $-33, %cl - WORD $0xc180; BYTE $0xb9 // addb $-71, %cl - WORD $0xf980; BYTE $0xfa // cmpb $-6, %cl - LONG $0xfe84820f; WORD $0xffff // jb LBB9_52, $-380(%rip) - -LBB9_102: - LONG $0x01488d48 // leaq $1(%rax), %rcx - LONG $0xd0558b48 // movq $-48(%rbp), %rdx - WORD $0x8948; BYTE $0x0a // movq %rcx, (%rdx) - LONG $0x4fb60f41; BYTE $0x03 // movzbl $3(%r15), %ecx - WORD $0x518d; BYTE $0xc6 // leal $-58(%rcx), %edx - WORD $0xfa80; BYTE $0xf5 // cmpb $-11, %dl - LONG $0x000f870f; WORD $0x0000 // ja LBB9_104, $15(%rip) + WORD $0xc180; BYTE $0xbf // addb $-65, %cl + WORD $0xf980; BYTE $0x05 // cmpb $5, %cl + LONG $0xfed3870f; WORD $0xffff // ja LBB6_83, $-301(%rip) + +LBB6_99: + LONG $0x014a8d48 // leaq $1(%rdx), %rcx + LONG $0xc87d8b48 // movq $-56(%rbp), %rdi + WORD $0x8948; BYTE $0x0f // movq %rcx, (%rdi) + WORD $0x4e8a; BYTE $0x03 // movb $3(%rsi), %cl + WORD $0x798d; BYTE $0xd0 // leal $-48(%rcx), %edi + LONG $0x0aff8040 // cmpb $10, %dil + LONG $0x000f820f; WORD $0x0000 // jb LBB6_101, $15(%rip) WORD $0xe180; BYTE $0xdf // andb $-33, %cl - WORD $0xc180; BYTE $0xb9 // addb $-71, %cl - WORD $0xf980; BYTE $0xfa // cmpb $-6, %cl - LONG $0xfe59820f; WORD $0xffff // jb LBB9_52, $-423(%rip) - -LBB9_104: - LONG $0x02488d48 // leaq $2(%rax), %rcx - LONG $0xd0558b48 // movq $-48(%rbp), %rdx - WORD $0x8948; BYTE $0x0a // movq %rcx, (%rdx) - LONG $0x4fb60f41; BYTE $0x04 // movzbl $4(%r15), %ecx - WORD $0x518d; BYTE $0xc6 // leal $-58(%rcx), %edx - WORD $0xfa80; BYTE $0xf5 // cmpb $-11, %dl - LONG $0x000f870f; WORD $0x0000 // ja LBB9_106, $15(%rip) + WORD $0xc180; BYTE $0xbf // addb $-65, %cl + WORD $0xf980; BYTE $0x05 // cmpb $5, %cl + LONG $0xfea9870f; WORD $0xffff // ja LBB6_83, $-343(%rip) + +LBB6_101: + LONG $0x024a8d48 // leaq $2(%rdx), %rcx + LONG $0xc87d8b48 // movq $-56(%rbp), %rdi + WORD $0x8948; BYTE $0x0f // movq %rcx, (%rdi) + WORD $0x4e8a; BYTE $0x04 // movb $4(%rsi), %cl + WORD $0x798d; BYTE $0xd0 // leal $-48(%rcx), %edi + LONG $0x0aff8040 // cmpb $10, %dil + LONG $0x000f820f; WORD $0x0000 // jb LBB6_103, $15(%rip) WORD $0xe180; BYTE $0xdf // andb $-33, %cl - WORD $0xc180; BYTE $0xb9 // addb $-71, %cl - WORD $0xf980; BYTE $0xfa // cmpb $-6, %cl - LONG $0xfe2e820f; WORD $0xffff // jb LBB9_52, $-466(%rip) - -LBB9_106: - LONG $0x03488d48 // leaq $3(%rax), %rcx - LONG $0xd0558b48 // movq $-48(%rbp), %rdx - WORD $0x8948; BYTE $0x0a // movq %rcx, (%rdx) - LONG $0x4fb60f41; BYTE $0x05 // movzbl $5(%r15), %ecx - WORD $0x518d; BYTE $0xc6 // leal $-58(%rcx), %edx - WORD $0xfa80; BYTE $0xf5 // cmpb $-11, %dl - LONG $0x000f870f; WORD $0x0000 // ja LBB9_108, $15(%rip) + WORD $0xc180; BYTE $0xbf // addb $-65, %cl + WORD $0xf980; BYTE $0x05 // cmpb $5, %cl + LONG $0xfe7f870f; WORD $0xffff // ja LBB6_83, $-385(%rip) + +LBB6_103: + LONG $0x034a8d48 // leaq $3(%rdx), %rcx + LONG $0xc87d8b48 // movq $-56(%rbp), %rdi + WORD $0x8948; BYTE $0x0f // movq %rcx, (%rdi) + WORD $0x4e8a; BYTE $0x05 // movb $5(%rsi), %cl + WORD $0x718d; BYTE $0xd0 // leal $-48(%rcx), %esi + LONG $0x0afe8040 // cmpb $10, %sil + LONG $0x000f820f; WORD $0x0000 // jb LBB6_105, $15(%rip) WORD $0xe180; BYTE $0xdf // andb $-33, %cl - WORD $0xc180; BYTE $0xb9 // addb $-71, %cl - WORD $0xf980; BYTE $0xfa // cmpb $-6, %cl - LONG $0xfe03820f; WORD $0xffff // jb LBB9_52, $-509(%rip) + WORD $0xc180; BYTE $0xbf // addb $-65, %cl + WORD $0xf980; BYTE $0x05 // cmpb $5, %cl + LONG $0xfe55870f; WORD $0xffff // ja LBB6_83, $-427(%rip) -LBB9_108: - LONG $0x04c08348 // addq $4, %rax - LONG $0xd04d8b48 // movq $-48(%rbp), %rcx - WORD $0x8948; BYTE $0x01 // movq %rax, (%rcx) - LONG $0xfffdf3e9; BYTE $0xff // jmp LBB9_52, $-525(%rip) +LBB6_105: + LONG $0x04c28348 // addq $4, %rdx + LONG $0xc84d8b48 // movq $-56(%rbp), %rcx + WORD $0x8948; BYTE $0x11 // movq %rdx, (%rcx) + LONG $0xfffe45e9; BYTE $0xff // jmp LBB6_83, $-443(%rip) -LBB9_97: - LONG $0xc87d894c // movq %r15, $-56(%rbp) +LBB6_106: + WORD $0x2949; BYTE $0xf9 // subq %rdi, %r9 + WORD $0xff49; BYTE $0xc1 // incq %r9 -LBB9_98: - LONG $0xc8658b4c // movq $-56(%rbp), %r12 - LONG $0xc0652b4c // subq $-64(%rbp), %r12 - LONG $0xfcc48349 // addq $-4, %r12 - LONG $0xd0458b48 // movq $-48(%rbp), %rax - WORD $0x894c; BYTE $0x20 // movq %r12, (%rax) - LONG $0xfcc6c749; WORD $0xffff; BYTE $0xff // movq $-4, %r14 - LONG $0xfffdd0e9; BYTE $0xff // jmp LBB9_52, $-560(%rip) +LBB6_107: + LONG $0xc8458b48 // movq $-56(%rbp), %rax + WORD $0x894c; BYTE $0x08 // movq %r9, (%rax) + LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq $-2, %rax + LONG $0xfffe2ce9; BYTE $0xff // jmp LBB6_83, $-468(%rip) -LBB9_87: - LONG $0xd0458b48 // movq $-48(%rbp), %rax - LONG $0xb04d8b48 // movq $-80(%rbp), %rcx - WORD $0x8948; BYTE $0x08 // movq %rcx, (%rax) - LONG $0xffc6c749; WORD $0xffff; BYTE $0xff // movq $-1, %r14 - LONG $0xfffdb9e9; BYTE $0xff // jmp LBB9_52, $-583(%rip) - QUAD $0x9090909090909090 // .p2align 4, 0x90 +LBB6_108: + LONG $0x02b845f6 // testb $2, $-72(%rbp) + LONG $0x0015840f; WORD $0x0000 // je LBB6_111, $21(%rip) + LONG $0xef00c766; BYTE $0xbf // movw $-16401, (%rax) + LONG $0xbd0240c6 // movb $-67, $2(%rax) + LONG $0x03c08348 // addq $3, %rax -_unhex16_is: - BYTE $0x55 // pushq %rbp - WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp - WORD $0xf889 // movl %edi, %eax - WORD $0xd0f7 // notl %eax - LONG $0xcfd08f8d; WORD $0xcfcf // leal $-808464432(%rdi), %ecx - LONG $0x80808025; BYTE $0x80 // andl $-2139062144, %eax - WORD $0xc885 // testl %ecx, %eax - LONG $0x0007840f; WORD $0x0000 // je LBB10_2, $7(%rip) - WORD $0xc031 // xorl %eax, %eax - WORD $0xb60f; BYTE $0xc0 // movzbl %al, %eax - BYTE $0x5d // popq %rbp - BYTE $0xc3 // retq +LBB6_110: + WORD $0x3145; BYTE $0xed // xorl %r13d, %r13d + LONG $0xfffe07e9; BYTE $0xff // jmp LBB6_82, $-505(%rip) -LBB10_2: - LONG $0x19198f8d; WORD $0x1919 // leal $421075225(%rdi), %ecx - WORD $0xf909 // orl %edi, %ecx - LONG $0x8080c1f7; WORD $0x8080 // testl $-2139062144, %ecx - LONG $0x0007840f; WORD $0x0000 // je LBB10_4, $7(%rip) - WORD $0xc031 // xorl %eax, %eax - WORD $0xb60f; BYTE $0xc0 // movzbl %al, %eax - BYTE $0x5d // popq %rbp - BYTE $0xc3 // retq +LBB6_111: + LONG $0xc8458b48 // movq $-56(%rbp), %rax + WORD $0x894c; BYTE $0x18 // movq %r11, (%rax) + LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax + LONG $0xfffdfae9; BYTE $0xff // jmp LBB6_83, $-518(%rip) -LBB10_4: - LONG $0x7f7fe781; WORD $0x7f7f // andl $2139062143, %edi - LONG $0xc0c0c0b9; BYTE $0xc0 // movl $-1061109568, %ecx - WORD $0xf929 // subl %edi, %ecx - LONG $0x4646978d; WORD $0x4646 // leal $1179010630(%rdi), %edx - WORD $0xc121 // andl %eax, %ecx - WORD $0xd185 // testl %edx, %ecx - LONG $0x0007840f; WORD $0x0000 // je LBB10_6, $7(%rip) - WORD $0xc031 // xorl %eax, %eax - WORD $0xb60f; BYTE $0xc0 // movzbl %al, %eax - BYTE $0x5d // popq %rbp - BYTE $0xc3 // retq +LBB6_112: + WORD $0x2949; BYTE $0xf9 // subq %rdi, %r9 + LONG $0xfcc18349 // addq $-4, %r9 -LBB10_6: - LONG $0xe0e0e0b9; BYTE $0xe0 // movl $-522133280, %ecx - WORD $0xf929 // subl %edi, %ecx - LONG $0x3939c781; WORD $0x3939 // addl $960051513, %edi - WORD $0xc821 // andl %ecx, %eax - WORD $0xf885 // testl %edi, %eax - WORD $0x940f; BYTE $0xc0 // sete %al - WORD $0xb60f; BYTE $0xc0 // movzbl %al, %eax - BYTE $0x5d // popq %rbp - BYTE $0xc3 // retq - LONG $0x00000000; WORD $0x0000 // .p2align 4, 0x00 +LBB6_113: + LONG $0xc8458b48 // movq $-56(%rbp), %rax + WORD $0x894c; BYTE $0x08 // movq %r9, (%rax) + LONG $0xfcc0c748; WORD $0xffff; BYTE $0xff // movq $-4, %rax + LONG $0xfffde0e9; BYTE $0xff // jmp LBB6_83, $-544(%rip) -LCPI11_0: +LBB6_114: + LONG $0x21448d4b; BYTE $0x0a // leaq $10(%r9,%r12), %rax + LONG $0x000005e9; BYTE $0x00 // jmp LBB6_116, $5(%rip) + +LBB6_115: + LONG $0x21448d4b; BYTE $0x0b // leaq $11(%r9,%r12), %rax + +LBB6_116: + WORD $0x2948; BYTE $0xf8 // subq %rdi, %rax + LONG $0xfcc08348 // addq $-4, %rax + LONG $0xc84d8b48 // movq $-56(%rbp), %rcx + WORD $0x8948; BYTE $0x01 // movq %rax, (%rcx) + LONG $0xfcc0c748; WORD $0xffff; BYTE $0xff // movq $-4, %rax + LONG $0xfffdb7e9; BYTE $0xff // jmp LBB6_83, $-585(%rip) + +LBB6_117: + LONG $0x3a448d49; BYTE $0x04 // leaq $4(%r10,%rdi), %rax + WORD $0x2949; BYTE $0xc1 // subq %rax, %r9 + LONG $0xffffb7e9; BYTE $0xff // jmp LBB6_113, $-73(%rip) + +LBB6_118: + WORD $0x014d; BYTE $0xe1 // addq %r12, %r9 + WORD $0x2949; BYTE $0xf9 // subq %rdi, %r9 + LONG $0xfffface9; BYTE $0xff // jmp LBB6_113, $-84(%rip) + QUAD $0x0000000000000000; WORD $0x0000 // .p2align 4, 0x00 + +LCPI7_0: QUAD $0x2626262626262626; QUAD $0x2626262626262626 // .space 16, '&&&&&&&&&&&&&&&&' -LCPI11_1: +LCPI7_1: QUAD $0xe2e2e2e2e2e2e2e2; QUAD $0xe2e2e2e2e2e2e2e2 // .space 16, '\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2' -LCPI11_2: +LCPI7_2: QUAD $0xfdfdfdfdfdfdfdfd; QUAD $0xfdfdfdfdfdfdfdfd // .space 16, '\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd' -LCPI11_3: +LCPI7_3: QUAD $0x3c3c3c3c3c3c3c3c; QUAD $0x3c3c3c3c3c3c3c3c // .space 16, '<<<<<<<<<<<<<<<<' // .p2align 4, 0x90 @@ -2822,381 +2557,370 @@ _html_escape: BYTE $0x53 // pushq %rbx LONG $0x10ec8348 // subq $16, %rsp LONG $0xc84d8948 // movq %rcx, $-56(%rbp) - WORD $0x8949; BYTE $0xd6 // movq %rdx, %r14 + WORD $0x8949; BYTE $0xd2 // movq %rdx, %r10 LONG $0xd0558948 // movq %rdx, $-48(%rbp) WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax WORD $0x8548; BYTE $0xf6 // testq %rsi, %rsi - LONG $0x04b18e0f; WORD $0x0000 // jle LBB11_70, $1201(%rip) + LONG $0x04718e0f; WORD $0x0000 // jle LBB7_67, $1137(%rip) LONG $0xc8458b48 // movq $-56(%rbp), %rax WORD $0x8b4c; BYTE $0x08 // movq (%rax), %r9 - QUAD $0xffffff89056f0f66 // movdqa $-119(%rip), %xmm0 /* LCPI11_0(%rip) */ - QUAD $0xffffff910d6f0f66 // movdqa $-111(%rip), %xmm1 /* LCPI11_1(%rip) */ - QUAD $0xffffff99156f0f66 // movdqa $-103(%rip), %xmm2 /* LCPI11_2(%rip) */ - QUAD $0xffffffa11d6f0f66 // movdqa $-95(%rip), %xmm3 /* LCPI11_3(%rip) */ - LONG $0xfa1d8d4c; WORD $0x00d8; BYTE $0x00 // leaq $55546(%rip), %r11 /* __HtmlQuoteTab(%rip) */ - WORD $0x8949; BYTE $0xfc // movq %rdi, %r12 - LONG $0xd0758b4c // movq $-48(%rbp), %r14 + QUAD $0xffffff89056f0f66 // movdqa $-119(%rip), %xmm0 /* LCPI7_0(%rip) */ + QUAD $0xffffff910d6f0f66 // movdqa $-111(%rip), %xmm1 /* LCPI7_1(%rip) */ + QUAD $0xffffff99156f0f66 // movdqa $-103(%rip), %xmm2 /* LCPI7_2(%rip) */ + QUAD $0xffffffa11d6f0f66 // movdqa $-95(%rip), %xmm3 /* LCPI7_3(%rip) */ + LONG $0xfa1d8d4c; WORD $0x00e3; BYTE $0x00 // leaq $58362(%rip), %r11 /* __HtmlQuoteTab(%rip) */ + WORD $0x8949; BYTE $0xff // movq %rdi, %r15 + LONG $0xd0558b4c // movq $-48(%rbp), %r10 WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 -LBB11_2: - WORD $0x854d; BYTE $0xc9 // testq %r9, %r9 - LONG $0x048e8e0f; WORD $0x0000 // jle LBB11_3, $1166(%rip) - LONG $0x10fe8348 // cmpq $16, %rsi - WORD $0x930f; BYTE $0xc0 // setae %al - WORD $0x894d; BYTE $0xcd // movq %r9, %r13 - WORD $0x894d; BYTE $0xf0 // movq %r14, %r8 - WORD $0x8948; BYTE $0xf1 // movq %rsi, %rcx - WORD $0x894d; BYTE $0xe7 // movq %r12, %r15 - LONG $0x10f98349 // cmpq $16, %r9 - LONG $0x0082820f; WORD $0x0000 // jb LBB11_12, $130(%rip) - LONG $0x10fe8348 // cmpq $16, %rsi - LONG $0x0078820f; WORD $0x0000 // jb LBB11_12, $120(%rip) - WORD $0x3145; BYTE $0xc0 // xorl %r8d, %r8d - WORD $0x8948; BYTE $0xf3 // movq %rsi, %rbx - WORD $0x894c; BYTE $0xca // movq %r9, %rdx - LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 - -LBB11_7: - LONG $0x6f0f43f3; WORD $0x0424 // movdqu (%r12,%r8), %xmm4 - LONG $0xec6f0f66 // movdqa %xmm4, %xmm5 - LONG $0xf46f0f66 // movdqa %xmm4, %xmm6 - LONG $0x7f0f43f3; WORD $0x0624 // movdqu %xmm4, (%r14,%r8) - LONG $0xe0740f66 // pcmpeqb %xmm0, %xmm4 - LONG $0xe9740f66 // pcmpeqb %xmm1, %xmm5 - LONG $0xeceb0f66 // por %xmm4, %xmm5 - LONG $0xf2db0f66 // pand %xmm2, %xmm6 - LONG $0xf3740f66 // pcmpeqb %xmm3, %xmm6 - LONG $0xf5eb0f66 // por %xmm5, %xmm6 - LONG $0xc6d70f66 // pmovmskb %xmm6, %eax - WORD $0xc085 // testl %eax, %eax - LONG $0x0158850f; WORD $0x0000 // jne LBB11_8, $344(%rip) - LONG $0xf04b8d48 // leaq $-16(%rbx), %rcx - LONG $0xf06a8d4c // leaq $-16(%rdx), %r13 - LONG $0x10c08349 // addq $16, %r8 - LONG $0x20fb8348 // cmpq $32, %rbx - WORD $0x9d0f; BYTE $0xc0 // setge %al - LONG $0x00108c0f; WORD $0x0000 // jl LBB11_11, $16(%rip) - WORD $0x8948; BYTE $0xcb // movq %rcx, %rbx - LONG $0x1ffa8348 // cmpq $31, %rdx - WORD $0x894c; BYTE $0xea // movq %r13, %rdx - LONG $0xff9f8f0f; WORD $0xffff // jg LBB11_7, $-97(%rip) - -LBB11_11: - LONG $0x043c8d4f // leaq (%r12,%r8), %r15 - WORD $0x014d; BYTE $0xf0 // addq %r14, %r8 +LBB7_2: + WORD $0x854d; BYTE $0xc9 // testq %r9, %r9 + LONG $0x044e8e0f; WORD $0x0000 // jle LBB7_3, $1102(%rip) + LONG $0x0ffe8348 // cmpq $15, %rsi + WORD $0x9f0f; BYTE $0xc1 // setg %cl + WORD $0x894d; BYTE $0xcc // movq %r9, %r12 + WORD $0x894d; BYTE $0xd0 // movq %r10, %r8 + WORD $0x8948; BYTE $0xf2 // movq %rsi, %rdx + WORD $0x894d; BYTE $0xfd // movq %r15, %r13 + LONG $0x10f98349 // cmpq $16, %r9 + LONG $0x008a8c0f; WORD $0x0000 // jl LBB7_11, $138(%rip) + LONG $0x10fe8348 // cmpq $16, %rsi + LONG $0x00808c0f; WORD $0x0000 // jl LBB7_11, $128(%rip) + WORD $0x894d; BYTE $0xfd // movq %r15, %r13 + WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax + WORD $0x894d; BYTE $0xd0 // movq %r10, %r8 + WORD $0x894c; BYTE $0xcb // movq %r9, %rbx + LONG $0x90909090 // .p2align 4, 0x90 -LBB11_12: - WORD $0xc084 // testb %al, %al - LONG $0x0070840f; WORD $0x0000 // je LBB11_13, $112(%rip) - LONG $0x6f0f41f3; BYTE $0x27 // movdqu (%r15), %xmm4 +LBB7_7: + LONG $0x6f0f41f3; WORD $0x0065 // movdqu (%r13), %xmm4 LONG $0xec6f0f66 // movdqa %xmm4, %xmm5 - LONG $0xe8740f66 // pcmpeqb %xmm0, %xmm5 LONG $0xf46f0f66 // movdqa %xmm4, %xmm6 - LONG $0xf1740f66 // pcmpeqb %xmm1, %xmm6 + LONG $0x7f0f41f3; BYTE $0x20 // movdqu %xmm4, (%r8) + LONG $0xe0740f66 // pcmpeqb %xmm0, %xmm4 + LONG $0xe9740f66 // pcmpeqb %xmm1, %xmm5 + LONG $0xeceb0f66 // por %xmm4, %xmm5 + LONG $0xf2db0f66 // pand %xmm2, %xmm6 + LONG $0xf3740f66 // pcmpeqb %xmm3, %xmm6 LONG $0xf5eb0f66 // por %xmm5, %xmm6 - LONG $0x7e0f4866; BYTE $0xe0 // movq %xmm4, %rax - LONG $0xe2db0f66 // pand %xmm2, %xmm4 - LONG $0xe3740f66 // pcmpeqb %xmm3, %xmm4 - LONG $0xe6eb0f66 // por %xmm6, %xmm4 - LONG $0xccd70f66 // pmovmskb %xmm4, %ecx - LONG $0x0000c981; WORD $0x0001 // orl $65536, %ecx - LONG $0xd1bc0f44 // bsfl %ecx, %r10d - WORD $0x394d; BYTE $0xd5 // cmpq %r10, %r13 - LONG $0x00f88d0f; WORD $0x0000 // jge LBB11_24, $248(%rip) - LONG $0x08fd8349 // cmpq $8, %r13 - LONG $0x0131820f; WORD $0x0000 // jb LBB11_35, $305(%rip) - WORD $0x8949; BYTE $0x00 // movq %rax, (%r8) - LONG $0x08578d4d // leaq $8(%r15), %r10 - LONG $0x08c08349 // addq $8, %r8 - LONG $0xf85d8d49 // leaq $-8(%r13), %rbx - LONG $0x04fb8348 // cmpq $4, %rbx - LONG $0x01288d0f; WORD $0x0000 // jge LBB11_38, $296(%rip) - LONG $0x000135e9; BYTE $0x00 // jmp LBB11_39, $309(%rip) + LONG $0xced70f66 // pmovmskb %xmm6, %ecx + WORD $0x8566; BYTE $0xc9 // testw %cx, %cx + LONG $0x0138850f; WORD $0x0000 // jne LBB7_8, $312(%rip) + LONG $0x10c58349 // addq $16, %r13 + LONG $0x10c08349 // addq $16, %r8 + LONG $0xf0508d48 // leaq $-16(%rax), %rdx + LONG $0xf0638d4c // leaq $-16(%rbx), %r12 + LONG $0x1ff88348 // cmpq $31, %rax + WORD $0x9f0f; BYTE $0xc1 // setg %cl + LONG $0x20f88348 // cmpq $32, %rax + LONG $0x00178c0f; WORD $0x0000 // jl LBB7_11, $23(%rip) + WORD $0x8948; BYTE $0xd0 // movq %rdx, %rax + LONG $0x1ffb8348 // cmpq $31, %rbx + WORD $0x894c; BYTE $0xe3 // movq %r12, %rbx + LONG $0xff978f0f; WORD $0xffff // jg LBB7_7, $-105(%rip) LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 -LBB11_13: - WORD $0x8548; BYTE $0xc9 // testq %rcx, %rcx - LONG $0x00878e0f; WORD $0x0000 // jle LBB11_21, $135(%rip) - WORD $0x854d; BYTE $0xed // testq %r13, %r13 - LONG $0x007e8e0f; WORD $0x0000 // jle LBB11_21, $126(%rip) - WORD $0xd231 // xorl %edx, %edx - WORD $0xc031 // xorl %eax, %eax - QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90 - -LBB11_16: - LONG $0x1cb60f45; BYTE $0x17 // movzbl (%r15,%rdx), %r11d - LONG $0x3efb8349 // cmpq $62, %r11 - LONG $0x0014870f; WORD $0x0000 // ja LBB11_17, $20(%rip) - QUAD $0x004000000000bb48; WORD $0x5000 // movabsq $5764607797912141824, %rbx - LONG $0xdba30f4c // btq %r11, %rbx - LONG $0x00ae820f; WORD $0x0000 // jb LBB11_45, $174(%rip) +LBB7_11: + WORD $0xc984 // testb %cl, %cl + LONG $0x0078840f; WORD $0x0000 // je LBB7_12, $120(%rip) + LONG $0x6f0f41f3; WORD $0x0065 // movdqu (%r13), %xmm4 + LONG $0xec6f0f66 // movdqa %xmm4, %xmm5 + LONG $0xe8740f66 // pcmpeqb %xmm0, %xmm5 + LONG $0xf46f0f66 // movdqa %xmm4, %xmm6 + LONG $0xf1740f66 // pcmpeqb %xmm1, %xmm6 + LONG $0xf5eb0f66 // por %xmm5, %xmm6 + LONG $0x7e0f4866; BYTE $0xe0 // movq %xmm4, %rax + LONG $0xe2db0f66 // pand %xmm2, %xmm4 + LONG $0xe3740f66 // pcmpeqb %xmm3, %xmm4 + LONG $0xe6eb0f66 // por %xmm6, %xmm4 + LONG $0xccd70f66 // pmovmskb %xmm4, %ecx + LONG $0x0000c981; WORD $0x0001 // orl $65536, %ecx + LONG $0xf1bc0f44 // bsfl %ecx, %r14d + WORD $0x394d; BYTE $0xf4 // cmpq %r14, %r12 + LONG $0x00d18d0f; WORD $0x0000 // jge LBB7_15, $209(%rip) + LONG $0x08fc8349 // cmpq $8, %r12 + LONG $0x00f7820f; WORD $0x0000 // jb LBB7_26, $247(%rip) + WORD $0x8949; BYTE $0x00 // movq %rax, (%r8) + LONG $0x08758d4d // leaq $8(%r13), %r14 + LONG $0x08c08349 // addq $8, %r8 + LONG $0x24448d49; BYTE $0xf8 // leaq $-8(%r12), %rax + LONG $0x04f88348 // cmpq $4, %rax + LONG $0x00ed8d0f; WORD $0x0000 // jge LBB7_29, $237(%rip) + LONG $0x0000fae9; BYTE $0x00 // jmp LBB7_30, $250(%rip) + QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 -LBB11_17: - LONG $0xe2fb8141; WORD $0x0000; BYTE $0x00 // cmpl $226, %r11d - LONG $0x00a1840f; WORD $0x0000 // je LBB11_45, $161(%rip) - LONG $0x01148d4c // leaq (%rcx,%rax), %r10 - LONG $0x101c8845 // movb %r11b, (%r8,%rdx) - LONG $0xff588d48 // leaq $-1(%rax), %rbx - LONG $0x02fa8349 // cmpq $2, %r10 - LONG $0x00138c0f; WORD $0x0000 // jl LBB11_20, $19(%rip) - WORD $0x014c; BYTE $0xe8 // addq %r13, %rax - WORD $0xff48; BYTE $0xc2 // incq %rdx - LONG $0x01f88348 // cmpq $1, %rax - WORD $0x8948; BYTE $0xd8 // movq %rbx, %rax - LONG $0xffa78f0f; WORD $0xffff // jg LBB11_16, $-89(%rip) +LBB7_12: + WORD $0x854d; BYTE $0xe4 // testq %r12, %r12 + LONG $0x01148e0f; WORD $0x0000 // jle LBB7_13, $276(%rip) + WORD $0x8948; BYTE $0xd0 // movq %rdx, %rax + WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx + LONG $0x010b8e0f; WORD $0x0000 // jle LBB7_40, $267(%rip) + QUAD $0x9090909090909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 -LBB11_20: - WORD $0x2949; BYTE $0xdf // subq %rbx, %r15 - WORD $0x0148; BYTE $0xd9 // addq %rbx, %rcx - LONG $0x4a1d8d4c; WORD $0x00d7; BYTE $0x00 // leaq $55114(%rip), %r11 /* __HtmlQuoteTab(%rip) */ - QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90 +LBB7_36: + LONG $0x4db60f41; BYTE $0x00 // movzbl (%r13), %ecx + LONG $0x3ef98348 // cmpq $62, %rcx + LONG $0x0014870f; WORD $0x0000 // ja LBB7_37, $20(%rip) + QUAD $0x004000000000b848; WORD $0x5000 // movabsq $5764607797912141824, %rax + LONG $0xc8a30f48 // btq %rcx, %rax + LONG $0x0080820f; WORD $0x0000 // jb LBB7_42, $128(%rip) -LBB11_21: - WORD $0x8548; BYTE $0xc9 // testq %rcx, %rcx - LONG $0x0160840f; WORD $0x0000 // je LBB11_22, $352(%rip) - WORD $0xf749; BYTE $0xd7 // notq %r15 - WORD $0x014d; BYTE $0xe7 // addq %r12, %r15 - WORD $0x854d; BYTE $0xff // testq %r15, %r15 - LONG $0x0168890f; WORD $0x0000 // jns LBB11_49, $360(%rip) - LONG $0x000287e9; BYTE $0x00 // jmp LBB11_48, $647(%rip) +LBB7_37: + WORD $0xf980; BYTE $0xe2 // cmpb $-30, %cl + LONG $0x0077840f; WORD $0x0000 // je LBB7_42, $119(%rip) + LONG $0xff428d48 // leaq $-1(%rdx), %rax + WORD $0xff49; BYTE $0xc5 // incq %r13 + WORD $0x8841; BYTE $0x08 // movb %cl, (%r8) + LONG $0x02fa8348 // cmpq $2, %rdx + LONG $0x00c08c0f; WORD $0x0000 // jl LBB7_40, $192(%rip) + LONG $0x244c8d49; BYTE $0xff // leaq $-1(%r12), %rcx + WORD $0xff49; BYTE $0xc0 // incq %r8 + WORD $0x8948; BYTE $0xc2 // movq %rax, %rdx + LONG $0x01fc8349 // cmpq $1, %r12 + WORD $0x8949; BYTE $0xcc // movq %rcx, %r12 + LONG $0xffa88f0f; WORD $0xffff // jg LBB7_36, $-88(%rip) + LONG $0x0000a3e9; BYTE $0x00 // jmp LBB7_40, $163(%rip) WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 -LBB11_8: - LONG $0xc0bc0f66 // bsfw %ax, %ax - LONG $0xf8b70f44 // movzwl %ax, %r15d - WORD $0x014d; BYTE $0xc7 // addq %r8, %r15 - WORD $0x854d; BYTE $0xff // testq %r15, %r15 - LONG $0x014c890f; WORD $0x0000 // jns LBB11_49, $332(%rip) - LONG $0x00026be9; BYTE $0x00 // jmp LBB11_48, $619(%rip) +LBB7_8: + WORD $0xb70f; BYTE $0xc1 // movzwl %cx, %eax + WORD $0x294d; BYTE $0xfd // subq %r15, %r13 + LONG $0xe0bc0f44 // bsfl %eax, %r12d + WORD $0x014d; BYTE $0xec // addq %r13, %r12 + WORD $0x854d; BYTE $0xe4 // testq %r12, %r12 + LONG $0x00f3890f; WORD $0x0000 // jns LBB7_46, $243(%rip) + LONG $0x000249e9; BYTE $0x00 // jmp LBB7_45, $585(%rip) -LBB11_24: - LONG $0x08fa8341 // cmpl $8, %r10d - LONG $0x008f820f; WORD $0x0000 // jb LBB11_25, $143(%rip) +LBB7_15: + LONG $0x08fe8341 // cmpl $8, %r14d + LONG $0x0095820f; WORD $0x0000 // jb LBB7_16, $149(%rip) WORD $0x8949; BYTE $0x00 // movq %rax, (%r8) - LONG $0x086f8d4d // leaq $8(%r15), %r13 + LONG $0x08658d4d // leaq $8(%r13), %r12 LONG $0x08c08349 // addq $8, %r8 - LONG $0xf85a8d49 // leaq $-8(%r10), %rbx - LONG $0x04fb8348 // cmpq $4, %rbx - LONG $0x0086830f; WORD $0x0000 // jae LBB11_28, $134(%rip) - LONG $0x000094e9; BYTE $0x00 // jmp LBB11_29, $148(%rip) + LONG $0xf8468d49 // leaq $-8(%r14), %rax + LONG $0x04f88348 // cmpq $4, %rax + LONG $0x008c8d0f; WORD $0x0000 // jge LBB7_19, $140(%rip) + LONG $0x00009ae9; BYTE $0x00 // jmp LBB7_20, $154(%rip) -LBB11_45: - WORD $0x294d; BYTE $0xe7 // subq %r12, %r15 - WORD $0x2949; BYTE $0xc7 // subq %rax, %r15 - LONG $0xd21d8d4c; WORD $0x00d6; BYTE $0x00 // leaq $54994(%rip), %r11 /* __HtmlQuoteTab(%rip) */ - WORD $0x854d; BYTE $0xff // testq %r15, %r15 - LONG $0x0109890f; WORD $0x0000 // jns LBB11_49, $265(%rip) - LONG $0x000228e9; BYTE $0x00 // jmp LBB11_48, $552(%rip) +LBB7_42: + WORD $0x294d; BYTE $0xfd // subq %r15, %r13 + LONG $0x0000b2e9; BYTE $0x00 // jmp LBB7_43, $178(%rip) -LBB11_35: - WORD $0x894d; BYTE $0xfa // movq %r15, %r10 - WORD $0x894c; BYTE $0xeb // movq %r13, %rbx - LONG $0x04fb8348 // cmpq $4, %rbx - LONG $0x00128c0f; WORD $0x0000 // jl LBB11_39, $18(%rip) +LBB7_26: + WORD $0x894d; BYTE $0xee // movq %r13, %r14 + WORD $0x894c; BYTE $0xe0 // movq %r12, %rax + LONG $0x04f88348 // cmpq $4, %rax + LONG $0x00128c0f; WORD $0x0000 // jl LBB7_30, $18(%rip) -LBB11_38: - WORD $0x8b41; BYTE $0x02 // movl (%r10), %eax - WORD $0x8941; BYTE $0x00 // movl %eax, (%r8) - LONG $0x04c28349 // addq $4, %r10 +LBB7_29: + WORD $0x8b41; BYTE $0x0e // movl (%r14), %ecx + WORD $0x8941; BYTE $0x08 // movl %ecx, (%r8) + LONG $0x04c68349 // addq $4, %r14 LONG $0x04c08349 // addq $4, %r8 - LONG $0xfcc38348 // addq $-4, %rbx + LONG $0xfcc08348 // addq $-4, %rax -LBB11_39: - LONG $0x02fb8348 // cmpq $2, %rbx - LONG $0x007c830f; WORD $0x0000 // jae LBB11_40, $124(%rip) - WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx - LONG $0x0007840f; WORD $0x0000 // je LBB11_43, $7(%rip) +LBB7_30: + LONG $0x02f88348 // cmpq $2, %rax + LONG $0x015b830f; WORD $0x0000 // jae LBB7_31, $347(%rip) + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0x0006840f; WORD $0x0000 // je LBB7_34, $6(%rip) -LBB11_42: - LONG $0x02b60f41 // movzbl (%r10), %eax +LBB7_33: + WORD $0x8a41; BYTE $0x06 // movb (%r14), %al WORD $0x8841; BYTE $0x00 // movb %al, (%r8) -LBB11_43: - WORD $0x014d; BYTE $0xfd // addq %r15, %r13 - WORD $0xf749; BYTE $0xd5 // notq %r13 - WORD $0x014d; BYTE $0xe5 // addq %r12, %r13 - WORD $0x894d; BYTE $0xef // movq %r13, %r15 - WORD $0x854d; BYTE $0xff // testq %r15, %r15 - LONG $0x00b3890f; WORD $0x0000 // jns LBB11_49, $179(%rip) - LONG $0x0001d2e9; BYTE $0x00 // jmp LBB11_48, $466(%rip) +LBB7_34: + WORD $0x294d; BYTE $0xfc // subq %r15, %r12 + WORD $0x014d; BYTE $0xec // addq %r13, %r12 + WORD $0xf749; BYTE $0xd4 // notq %r12 + WORD $0x854d; BYTE $0xe4 // testq %r12, %r12 + LONG $0x0071890f; WORD $0x0000 // jns LBB7_46, $113(%rip) + LONG $0x0001c7e9; BYTE $0x00 // jmp LBB7_45, $455(%rip) -LBB11_25: - WORD $0x894d; BYTE $0xfd // movq %r15, %r13 - WORD $0x894c; BYTE $0xd3 // movq %r10, %rbx - LONG $0x04fb8348 // cmpq $4, %rbx - LONG $0x0013820f; WORD $0x0000 // jb LBB11_29, $19(%rip) +LBB7_13: + WORD $0x8948; BYTE $0xd0 // movq %rdx, %rax -LBB11_28: - LONG $0x00458b41 // movl (%r13), %eax - WORD $0x8941; BYTE $0x00 // movl %eax, (%r8) - LONG $0x04c58349 // addq $4, %r13 - LONG $0x04c08349 // addq $4, %r8 - LONG $0xfcc38348 // addq $-4, %rbx +LBB7_40: + WORD $0x294d; BYTE $0xfd // subq %r15, %r13 + WORD $0xf748; BYTE $0xd8 // negq %rax + WORD $0x194d; BYTE $0xe4 // sbbq %r12, %r12 + WORD $0x314d; BYTE $0xec // xorq %r13, %r12 + WORD $0x854d; BYTE $0xe4 // testq %r12, %r12 + LONG $0x0054890f; WORD $0x0000 // jns LBB7_46, $84(%rip) + LONG $0x0001aae9; BYTE $0x00 // jmp LBB7_45, $426(%rip) -LBB11_29: - LONG $0x02fb8348 // cmpq $2, %rbx - LONG $0x0047830f; WORD $0x0000 // jae LBB11_30, $71(%rip) - WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx - LONG $0x0008840f; WORD $0x0000 // je LBB11_33, $8(%rip) +LBB7_16: + WORD $0x894d; BYTE $0xec // movq %r13, %r12 + WORD $0x894c; BYTE $0xf0 // movq %r14, %rax + LONG $0x04f88348 // cmpq $4, %rax + LONG $0x00138c0f; WORD $0x0000 // jl LBB7_20, $19(%rip) -LBB11_32: - LONG $0x45b60f41; BYTE $0x00 // movzbl (%r13), %eax - WORD $0x8841; BYTE $0x00 // movb %al, (%r8) +LBB7_19: + LONG $0x240c8b41 // movl (%r12), %ecx + WORD $0x8941; BYTE $0x08 // movl %ecx, (%r8) + LONG $0x04c48349 // addq $4, %r12 + LONG $0x04c08349 // addq $4, %r8 + LONG $0xfcc08348 // addq $-4, %rax -LBB11_33: - WORD $0x294d; BYTE $0xe7 // subq %r12, %r15 - WORD $0x014d; BYTE $0xd7 // addq %r10, %r15 - WORD $0x854d; BYTE $0xff // testq %r15, %r15 - LONG $0x0061890f; WORD $0x0000 // jns LBB11_49, $97(%rip) - LONG $0x000180e9; BYTE $0x00 // jmp LBB11_48, $384(%rip) +LBB7_20: + LONG $0x02f88348 // cmpq $2, %rax + LONG $0x010d830f; WORD $0x0000 // jae LBB7_21, $269(%rip) + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0x0007840f; WORD $0x0000 // je LBB7_24, $7(%rip) -LBB11_40: - LONG $0x02b70f41 // movzwl (%r10), %eax - LONG $0x00894166 // movw %ax, (%r8) - LONG $0x02c28349 // addq $2, %r10 - LONG $0x02c08349 // addq $2, %r8 - LONG $0xfec38348 // addq $-2, %rbx - WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx - LONG $0xff70850f; WORD $0xffff // jne LBB11_42, $-144(%rip) - LONG $0xffff72e9; BYTE $0xff // jmp LBB11_43, $-142(%rip) +LBB7_23: + LONG $0x24048a41 // movb (%r12), %al + WORD $0x8841; BYTE $0x00 // movb %al, (%r8) -LBB11_30: - LONG $0x45b70f41; BYTE $0x00 // movzwl (%r13), %eax - LONG $0x00894166 // movw %ax, (%r8) - LONG $0x02c58349 // addq $2, %r13 - LONG $0x02c08349 // addq $2, %r8 - LONG $0xfec38348 // addq $-2, %rbx - WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx - LONG $0xffa4850f; WORD $0xffff // jne LBB11_32, $-92(%rip) - LONG $0xffffa7e9; BYTE $0xff // jmp LBB11_33, $-89(%rip) +LBB7_24: + WORD $0x294d; BYTE $0xfd // subq %r15, %r13 + WORD $0x014d; BYTE $0xf5 // addq %r14, %r13 -LBB11_22: - WORD $0x294d; BYTE $0xe7 // subq %r12, %r15 - WORD $0x854d; BYTE $0xff // testq %r15, %r15 - LONG $0x012f880f; WORD $0x0000 // js LBB11_48, $303(%rip) - QUAD $0x9090909090909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 +LBB7_43: + WORD $0x894d; BYTE $0xec // movq %r13, %r12 + WORD $0x854d; BYTE $0xe4 // testq %r12, %r12 + LONG $0x015b880f; WORD $0x0000 // js LBB7_45, $347(%rip) -LBB11_49: - WORD $0x014d; BYTE $0xfc // addq %r15, %r12 - WORD $0x014d; BYTE $0xfe // addq %r15, %r14 - WORD $0x294c; BYTE $0xfe // subq %r15, %rsi - LONG $0x01378e0f; WORD $0x0000 // jle LBB11_50, $311(%rip) - WORD $0x294d; BYTE $0xf9 // subq %r15, %r9 - LONG $0x0cb60f41; BYTE $0x24 // movzbl (%r12), %ecx +LBB7_46: + WORD $0x014d; BYTE $0xe7 // addq %r12, %r15 + WORD $0x014d; BYTE $0xe2 // addq %r12, %r10 + WORD $0x294c; BYTE $0xe6 // subq %r12, %rsi + LONG $0x016e8e0f; WORD $0x0000 // jle LBB7_47, $366(%rip) + WORD $0x294d; BYTE $0xe1 // subq %r12, %r9 + WORD $0x8a41; BYTE $0x0f // movb (%r15), %cl WORD $0xf980; BYTE $0xe2 // cmpb $-30, %cl - LONG $0x00b3840f; WORD $0x0000 // je LBB11_53, $179(%rip) - WORD $0x894c; BYTE $0xe0 // movq %r12, %rax + LONG $0x00f0840f; WORD $0x0000 // je LBB7_50, $240(%rip) + WORD $0x894c; BYTE $0xf8 // movq %r15, %rax -LBB11_57: - WORD $0xb60f; BYTE $0xc9 // movzbl %cl, %ecx - LONG $0x04e1c148 // shlq $4, %rcx - LONG $0x19148b4a // movq (%rcx,%r11), %rdx - WORD $0x6348; BYTE $0xda // movslq %edx, %rbx - WORD $0x2949; BYTE $0xd9 // subq %rbx, %r9 - LONG $0x01228c0f; WORD $0x0000 // jl LBB11_58, $290(%rip) - LONG $0x20e2c148 // shlq $32, %rdx - LONG $0x19148d4e // leaq (%rcx,%r11), %r10 - LONG $0x08c28349 // addq $8, %r10 - QUAD $0x000300000001b948; WORD $0x0000 // movabsq $12884901889, %rcx - WORD $0x3948; BYTE $0xca // cmpq %rcx, %rdx - LONG $0x00278c0f; WORD $0x0000 // jl LBB11_62, $39(%rip) - WORD $0x8b41; BYTE $0x0a // movl (%r10), %ecx - WORD $0x8941; BYTE $0x0e // movl %ecx, (%r14) - LONG $0x04c28349 // addq $4, %r10 - LONG $0x04468d4d // leaq $4(%r14), %r8 - LONG $0xfc4b8d48 // leaq $-4(%rbx), %rcx - LONG $0x02f98348 // cmpq $2, %rcx - LONG $0x001b830f; WORD $0x0000 // jae LBB11_65, $27(%rip) - LONG $0x00002ae9; BYTE $0x00 // jmp LBB11_66, $42(%rip) - LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 +LBB7_54: + WORD $0xb60f; BYTE $0xd1 // movzbl %cl, %edx + LONG $0x04e2c148 // shlq $4, %rdx + LONG $0x1a0c8b4a // movq (%rdx,%r11), %rcx + WORD $0x634c; BYTE $0xe1 // movslq %ecx, %r12 + WORD $0x294d; BYTE $0xe1 // subq %r12, %r9 + LONG $0x015b8c0f; WORD $0x0000 // jl LBB7_55, $347(%rip) + LONG $0x20e1c148 // shlq $32, %rcx + LONG $0x1a748d4e; BYTE $0x08 // leaq $8(%rdx,%r11), %r14 + QUAD $0x000300000001bb48; WORD $0x0000 // movabsq $12884901889, %rbx + WORD $0x3948; BYTE $0xd9 // cmpq %rbx, %rcx + LONG $0x00238c0f; WORD $0x0000 // jl LBB7_59, $35(%rip) + WORD $0x8b41; BYTE $0x0e // movl (%r14), %ecx + WORD $0x8941; BYTE $0x0a // movl %ecx, (%r10) + LONG $0x1a748d4e; BYTE $0x0c // leaq $12(%rdx,%r11), %r14 + LONG $0x04428d4d // leaq $4(%r10), %r8 + LONG $0x24548d49; BYTE $0xfc // leaq $-4(%r12), %rdx + LONG $0x02fa8348 // cmpq $2, %rdx + LONG $0x0015830f; WORD $0x0000 // jae LBB7_62, $21(%rip) + LONG $0x000024e9; BYTE $0x00 // jmp LBB7_63, $36(%rip) -LBB11_62: - WORD $0x894d; BYTE $0xf0 // movq %r14, %r8 - WORD $0x8948; BYTE $0xd9 // movq %rbx, %rcx - LONG $0x02f98348 // cmpq $2, %rcx - LONG $0x0014820f; WORD $0x0000 // jb LBB11_66, $20(%rip) + // .p2align 4, 0x90 +LBB7_59: + WORD $0x894d; BYTE $0xd0 // movq %r10, %r8 + WORD $0x894c; BYTE $0xe2 // movq %r12, %rdx + LONG $0x02fa8348 // cmpq $2, %rdx + LONG $0x0014820f; WORD $0x0000 // jb LBB7_63, $20(%rip) -LBB11_65: - LONG $0x12b70f41 // movzwl (%r10), %edx - LONG $0x10894166 // movw %dx, (%r8) - LONG $0x02c28349 // addq $2, %r10 +LBB7_62: + LONG $0x0eb70f41 // movzwl (%r14), %ecx + LONG $0x08894166 // movw %cx, (%r8) + LONG $0x02c68349 // addq $2, %r14 LONG $0x02c08349 // addq $2, %r8 - LONG $0xfec18348 // addq $-2, %rcx + LONG $0xfec28348 // addq $-2, %rdx -LBB11_66: - WORD $0x8548; BYTE $0xc9 // testq %rcx, %rcx - LONG $0x0007840f; WORD $0x0000 // je LBB11_68, $7(%rip) - LONG $0x0ab60f41 // movzbl (%r10), %ecx +LBB7_63: + WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx + LONG $0x0006840f; WORD $0x0000 // je LBB7_65, $6(%rip) + WORD $0x8a41; BYTE $0x0e // movb (%r14), %cl WORD $0x8841; BYTE $0x08 // movb %cl, (%r8) -LBB11_68: - WORD $0x0149; BYTE $0xde // addq %rbx, %r14 +LBB7_65: + WORD $0x014d; BYTE $0xe2 // addq %r12, %r10 -LBB11_69: +LBB7_66: WORD $0xff48; BYTE $0xc0 // incq %rax LONG $0xff4e8d48 // leaq $-1(%rsi), %rcx - WORD $0x8949; BYTE $0xc4 // movq %rax, %r12 + WORD $0x8949; BYTE $0xc7 // movq %rax, %r15 LONG $0x01fe8348 // cmpq $1, %rsi WORD $0x8948; BYTE $0xce // movq %rcx, %rsi - LONG $0xfc02870f; WORD $0xffff // ja LBB11_2, $-1022(%rip) - LONG $0x000076e9; BYTE $0x00 // jmp LBB11_70, $118(%rip) + LONG $0xfc838f0f; WORD $0xffff // jg LBB7_2, $-893(%rip) + LONG $0x0000b7e9; BYTE $0x00 // jmp LBB7_67, $183(%rip) -LBB11_53: +LBB7_31: + LONG $0x0eb70f41 // movzwl (%r14), %ecx + LONG $0x08894166 // movw %cx, (%r8) + LONG $0x02c68349 // addq $2, %r14 + LONG $0x02c08349 // addq $2, %r8 + LONG $0xfec08348 // addq $-2, %rax + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0xfe91850f; WORD $0xffff // jne LBB7_33, $-367(%rip) + LONG $0xfffe92e9; BYTE $0xff // jmp LBB7_34, $-366(%rip) + +LBB7_21: + LONG $0x0cb70f41; BYTE $0x24 // movzwl (%r12), %ecx + LONG $0x08894166 // movw %cx, (%r8) + LONG $0x02c48349 // addq $2, %r12 + LONG $0x02c08349 // addq $2, %r8 + LONG $0xfec08348 // addq $-2, %rax + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0xfede850f; WORD $0xffff // jne LBB7_23, $-290(%rip) + LONG $0xfffee0e9; BYTE $0xff // jmp LBB7_24, $-288(%rip) + +LBB7_50: LONG $0x03fe8348 // cmpq $3, %rsi - LONG $0x002c820f; WORD $0x0000 // jb LBB11_59, $44(%rip) - LONG $0x247c8041; WORD $0x8001 // cmpb $-128, $1(%r12) - LONG $0x0020850f; WORD $0x0000 // jne LBB11_59, $32(%rip) - LONG $0x4cb60f41; WORD $0x0224 // movzbl $2(%r12), %ecx + LONG $0x00288c0f; WORD $0x0000 // jl LBB7_56, $40(%rip) + LONG $0x017f8041; BYTE $0x80 // cmpb $-128, $1(%r15) + LONG $0x001d850f; WORD $0x0000 // jne LBB7_56, $29(%rip) + LONG $0x024f8a41 // movb $2(%r15), %cl WORD $0xc889 // movl %ecx, %eax WORD $0xfe24 // andb $-2, %al WORD $0xa83c // cmpb $-88, %al - LONG $0x000e850f; WORD $0x0000 // jne LBB11_59, $14(%rip) - LONG $0x24448d49; BYTE $0x02 // leaq $2(%r12), %rax + LONG $0x000d850f; WORD $0x0000 // jne LBB7_56, $13(%rip) + LONG $0x02478d49 // leaq $2(%r15), %rax LONG $0xfec68348 // addq $-2, %rsi - LONG $0xffff1ae9; BYTE $0xff // jmp LBB11_57, $-230(%rip) + LONG $0xfffee1e9; BYTE $0xff // jmp LBB7_54, $-287(%rip) -LBB11_59: +LBB7_56: WORD $0x854d; BYTE $0xc9 // testq %r9, %r9 - LONG $0x00558e0f; WORD $0x0000 // jle LBB11_3, $85(%rip) - LONG $0xe206c641 // movb $-30, (%r14) - WORD $0xff49; BYTE $0xc6 // incq %r14 + LONG $0x00558e0f; WORD $0x0000 // jle LBB7_3, $85(%rip) + LONG $0xe202c641 // movb $-30, (%r10) + WORD $0xff49; BYTE $0xc2 // incq %r10 WORD $0xff49; BYTE $0xc9 // decq %r9 - WORD $0x894c; BYTE $0xe0 // movq %r12, %rax - LONG $0xffff93e9; BYTE $0xff // jmp LBB11_69, $-109(%rip) + WORD $0x894c; BYTE $0xf8 // movq %r15, %rax + LONG $0xffff52e9; BYTE $0xff // jmp LBB7_66, $-174(%rip) -LBB11_48: - LONG $0xd04d8b48 // movq $-48(%rbp), %rcx - WORD $0x014c; BYTE $0xf9 // addq %r15, %rcx - WORD $0xf748; BYTE $0xd1 // notq %rcx - WORD $0x014c; BYTE $0xf1 // addq %r14, %rcx - LONG $0xc8458b48 // movq $-56(%rbp), %rax - WORD $0x8948; BYTE $0x08 // movq %rcx, (%rax) - WORD $0x294c; BYTE $0xe7 // subq %r12, %rdi - WORD $0x014c; BYTE $0xff // addq %r15, %rdi +LBB7_45: + LONG $0xd0552b4c // subq $-48(%rbp), %r10 + WORD $0x894c; BYTE $0xe0 // movq %r12, %rax + WORD $0xf748; BYTE $0xd0 // notq %rax + WORD $0x014c; BYTE $0xd0 // addq %r10, %rax + LONG $0xc84d8b48 // movq $-56(%rbp), %rcx + WORD $0x8948; BYTE $0x01 // movq %rax, (%rcx) + WORD $0x294c; BYTE $0xff // subq %r15, %rdi + WORD $0x014c; BYTE $0xe7 // addq %r12, %rdi WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax - LONG $0x00002ae9; BYTE $0x00 // jmp LBB11_71, $42(%rip) + LONG $0x00002ae9; BYTE $0x00 // jmp LBB7_68, $42(%rip) -LBB11_50: - WORD $0x894c; BYTE $0xe0 // movq %r12, %rax +LBB7_47: + WORD $0x894c; BYTE $0xf8 // movq %r15, %rax -LBB11_70: - LONG $0xd0752b4c // subq $-48(%rbp), %r14 +LBB7_67: + LONG $0xd0552b4c // subq $-48(%rbp), %r10 LONG $0xc84d8b48 // movq $-56(%rbp), %rcx - WORD $0x894c; BYTE $0x31 // movq %r14, (%rcx) + WORD $0x894c; BYTE $0x11 // movq %r10, (%rcx) WORD $0x2948; BYTE $0xf8 // subq %rdi, %rax - LONG $0x000014e9; BYTE $0x00 // jmp LBB11_71, $20(%rip) + LONG $0x000014e9; BYTE $0x00 // jmp LBB7_68, $20(%rip) -LBB11_58: - LONG $0xd0752b4c // subq $-48(%rbp), %r14 +LBB7_55: + LONG $0xd0552b4c // subq $-48(%rbp), %r10 LONG $0xc8458b48 // movq $-56(%rbp), %rax - WORD $0x894c; BYTE $0x30 // movq %r14, (%rax) + WORD $0x894c; BYTE $0x10 // movq %r10, (%rax) -LBB11_3: - WORD $0xf749; BYTE $0xd4 // notq %r12 - WORD $0x0149; BYTE $0xfc // addq %rdi, %r12 - WORD $0x894c; BYTE $0xe0 // movq %r12, %rax +LBB7_3: + WORD $0xf749; BYTE $0xd7 // notq %r15 + WORD $0x0149; BYTE $0xff // addq %rdi, %r15 + WORD $0x894c; BYTE $0xf8 // movq %r15, %rax -LBB11_71: +LBB7_68: LONG $0x10c48348 // addq $16, %rsp BYTE $0x5b // popq %rbx WORD $0x5c41 // popq %r12 @@ -3212,122 +2936,118 @@ _atof_eisel_lemire64: WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp WORD $0x5741 // pushq %r15 WORD $0x5641 // pushq %r14 - WORD $0x5441 // pushq %r12 BYTE $0x53 // pushq %rbx - LONG $0xfea4868d; WORD $0xffff // leal $-348(%rsi), %eax - LONG $0xfffd483d; BYTE $0xff // cmpl $-696, %eax - LONG $0x0122820f; WORD $0x0000 // jb LBB12_1, $290(%rip) + LONG $0x015c868d; WORD $0x0000 // leal $348(%rsi), %eax + LONG $0x0002b73d; BYTE $0x00 // cmpl $695, %eax + LONG $0x0115870f; WORD $0x0000 // ja LBB8_1, $277(%rip) WORD $0x8949; BYTE $0xc8 // movq %rcx, %r8 WORD $0x8941; BYTE $0xd1 // movl %edx, %r9d WORD $0x8548; BYTE $0xff // testq %rdi, %rdi - LONG $0x000d840f; WORD $0x0000 // je LBB12_4, $13(%rip) + LONG $0x000d840f; WORD $0x0000 // je LBB8_4, $13(%rip) LONG $0xd7bd0f4c // bsrq %rdi, %r10 LONG $0x3ff28349 // xorq $63, %r10 - LONG $0x000006e9; BYTE $0x00 // jmp LBB12_5, $6(%rip) + LONG $0x000006e9; BYTE $0x00 // jmp LBB8_5, $6(%rip) -LBB12_4: +LBB8_4: LONG $0x0040ba41; WORD $0x0000 // movl $64, %r10d -LBB12_5: +LBB8_5: WORD $0x8944; BYTE $0xd1 // movl %r10d, %ecx WORD $0xd348; BYTE $0xe7 // shlq %cl, %rdi - LONG $0x015c8e8d; WORD $0x0000 // leal $348(%rsi), %ecx - LONG $0x04e1c148 // shlq $4, %rcx - LONG $0x3b258d4c; WORD $0x005e; BYTE $0x00 // leaq $24123(%rip), %r12 /* _POW10_M128_TAB(%rip) */ + WORD $0xc389 // movl %eax, %ebx + LONG $0x04e3c148 // shlq $4, %rbx + LONG $0x81358d4c; WORD $0x0069; BYTE $0x00 // leaq $27009(%rip), %r14 /* _POW10_M128_TAB(%rip) */ WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax - LONG $0x2164f74a; BYTE $0x08 // mulq $8(%rcx,%r12) + LONG $0x3364f74a; BYTE $0x08 // mulq $8(%rbx,%r14) WORD $0x8949; BYTE $0xc7 // movq %rax, %r15 WORD $0x8949; BYTE $0xd3 // movq %rdx, %r11 - WORD $0x8944; BYTE $0xdb // movl %r11d, %ebx - LONG $0x01ffe381; WORD $0x0000 // andl $511, %ebx - LONG $0xfffb8148; WORD $0x0001; BYTE $0x00 // cmpq $511, %rbx - LONG $0x0050850f; WORD $0x0000 // jne LBB12_11, $80(%rip) - WORD $0x8949; BYTE $0xfe // movq %rdi, %r14 - WORD $0xf749; BYTE $0xd6 // notq %r14 + WORD $0x8944; BYTE $0xd8 // movl %r11d, %eax + LONG $0x0001ff25; BYTE $0x00 // andl $511, %eax + WORD $0x8948; BYTE $0xf9 // movq %rdi, %rcx + WORD $0xf748; BYTE $0xd1 // notq %rcx + WORD $0x3949; BYTE $0xcf // cmpq %rcx, %r15 + LONG $0x004f860f; WORD $0x0000 // jbe LBB8_11, $79(%rip) WORD $0x894c; BYTE $0xfa // movq %r15, %rdx - WORD $0x394d; BYTE $0xf7 // cmpq %r14, %r15 - LONG $0x0041860f; WORD $0x0000 // jbe LBB12_13, $65(%rip) + LONG $0x0001ff3d; BYTE $0x00 // cmpl $511, %eax + LONG $0x0044850f; WORD $0x0000 // jne LBB8_13, $68(%rip) WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax - LONG $0x2124f74a // mulq (%rcx,%r12) + LONG $0x3324f74a // mulq (%rbx,%r14) WORD $0x014c; BYTE $0xfa // addq %r15, %rdx LONG $0x00d38349 // adcq $0, %r11 - WORD $0x8944; BYTE $0xd9 // movl %r11d, %ecx - WORD $0xd1f7 // notl %ecx - LONG $0x37e1c148 // shlq $55, %rcx - LONG $0x0013850f; WORD $0x0000 // jne LBB12_12, $19(%rip) + WORD $0x3948; BYTE $0xc8 // cmpq %rcx, %rax + LONG $0x001d860f; WORD $0x0000 // jbe LBB8_12, $29(%rip) LONG $0xfffa8348 // cmpq $-1, %rdx - LONG $0x0009850f; WORD $0x0000 // jne LBB12_12, $9(%rip) - WORD $0x394c; BYTE $0xf0 // cmpq %r14, %rax - LONG $0x0083870f; WORD $0x0000 // ja LBB12_1, $131(%rip) - -LBB12_12: - WORD $0x8944; BYTE $0xdb // movl %r11d, %ebx - LONG $0x01ffe381; WORD $0x0000 // andl $511, %ebx - LONG $0x000003e9; BYTE $0x00 // jmp LBB12_13, $3(%rip) - -LBB12_11: + LONG $0x0013850f; WORD $0x0000 // jne LBB8_12, $19(%rip) + WORD $0x8944; BYTE $0xd8 // movl %r11d, %eax + LONG $0x0001ff25; BYTE $0x00 // andl $511, %eax + LONG $0x0001ff3d; BYTE $0x00 // cmpl $511, %eax + LONG $0x0079840f; WORD $0x0000 // je LBB8_1, $121(%rip) + +LBB8_12: + WORD $0x8944; BYTE $0xd8 // movl %r11d, %eax + LONG $0x0001ff25; BYTE $0x00 // andl $511, %eax + LONG $0x000003e9; BYTE $0x00 // jmp LBB8_13, $3(%rip) + +LBB8_11: WORD $0x894c; BYTE $0xfa // movq %r15, %rdx -LBB12_13: - WORD $0x894c; BYTE $0xd8 // movq %r11, %rax - LONG $0x3fe8c148 // shrq $63, %rax - WORD $0x488d; BYTE $0x09 // leal $9(%rax), %ecx +LBB8_13: + WORD $0x894c; BYTE $0xdf // movq %r11, %rdi + LONG $0x3fefc148 // shrq $63, %rdi + WORD $0x4f8d; BYTE $0x09 // leal $9(%rdi), %ecx WORD $0xd349; BYTE $0xeb // shrq %cl, %r11 - WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx - LONG $0x0018850f; WORD $0x0000 // jne LBB12_17, $24(%rip) - WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx - LONG $0x000f850f; WORD $0x0000 // jne LBB12_17, $15(%rip) - WORD $0x8944; BYTE $0xd9 // movl %r11d, %ecx - WORD $0xe183; BYTE $0x03 // andl $3, %ecx - WORD $0xf983; BYTE $0x01 // cmpl $1, %ecx - LONG $0x0044840f; WORD $0x0000 // je LBB12_1, $68(%rip) - -LBB12_17: - LONG $0x526ace69; WORD $0x0003 // imull $217706, %esi, %ecx - WORD $0xf9c1; BYTE $0x10 // sarl $16, %ecx - LONG $0x043fc181; WORD $0x0000 // addl $1087, %ecx - WORD $0x6348; BYTE $0xf1 // movslq %ecx, %rsi - WORD $0x294c; BYTE $0xd6 // subq %r10, %rsi - WORD $0x8944; BYTE $0xda // movl %r11d, %edx - WORD $0xe283; BYTE $0x01 // andl $1, %edx - WORD $0x014c; BYTE $0xda // addq %r11, %rdx - WORD $0x8948; BYTE $0xd1 // movq %rdx, %rcx - LONG $0x36e9c148 // shrq $54, %rcx - WORD $0x0148; BYTE $0xf0 // addq %rsi, %rax + WORD $0x0948; BYTE $0xd0 // orq %rdx, %rax + LONG $0x000f850f; WORD $0x0000 // jne LBB8_16, $15(%rip) + WORD $0x8944; BYTE $0xd8 // movl %r11d, %eax + WORD $0xe083; BYTE $0x03 // andl $3, %eax + WORD $0xf883; BYTE $0x01 // cmpl $1, %eax + LONG $0x0044840f; WORD $0x0000 // je LBB8_1, $68(%rip) + +LBB8_16: + LONG $0x526ac669; WORD $0x0003 // imull $217706, %esi, %eax + WORD $0xf8c1; BYTE $0x10 // sarl $16, %eax + LONG $0x00043f05; BYTE $0x00 // addl $1087, %eax + WORD $0x6348; BYTE $0xd0 // movslq %eax, %rdx + WORD $0x8944; BYTE $0xd8 // movl %r11d, %eax + WORD $0xe083; BYTE $0x01 // andl $1, %eax + WORD $0x014c; BYTE $0xd8 // addq %r11, %rax + QUAD $0x000000000000b948; WORD $0x01c0 // movabsq $126100789566373888, %rcx + WORD $0x2148; BYTE $0xc1 // andq %rax, %rcx + WORD $0x294c; BYTE $0xd2 // subq %r10, %rdx + LONG $0x3a548d48; BYTE $0xfe // leaq $-2(%rdx,%rdi), %rdx LONG $0x01f98348 // cmpq $1, %rcx - LONG $0x00d88348 // sbbq $0, %rax - LONG $0x01b08d48; WORD $0xfff8; BYTE $0xff // leaq $-2047(%rax), %rsi - LONG $0x02fe8148; WORD $0xfff8; BYTE $0xff // cmpq $-2046, %rsi - LONG $0x000b830f; WORD $0x0000 // jae LBB12_19, $11(%rip) + LONG $0xffda8348 // sbbq $-1, %rdx + LONG $0xfdfa8148; WORD $0x0007; BYTE $0x00 // cmpq $2045, %rdx + LONG $0x0009860f; WORD $0x0000 // jbe LBB8_18, $9(%rip) -LBB12_1: +LBB8_1: WORD $0xc031 // xorl %eax, %eax -LBB12_20: +LBB8_19: BYTE $0x5b // popq %rbx - WORD $0x5c41 // popq %r12 WORD $0x5e41 // popq %r14 WORD $0x5f41 // popq %r15 BYTE $0x5d // popq %rbp BYTE $0xc3 // retq -LBB12_19: +LBB8_18: + WORD $0xff48; BYTE $0xc2 // incq %rdx LONG $0x01f98348 // cmpq $1, %rcx WORD $0x02b1 // movb $2, %cl WORD $0xd980; BYTE $0x00 // sbbb $0, %cl - WORD $0xd348; BYTE $0xea // shrq %cl, %rdx - LONG $0x34e0c148 // shlq $52, %rax + WORD $0xd348; BYTE $0xe8 // shrq %cl, %rax + LONG $0x34e2c148 // shlq $52, %rdx QUAD $0xffffffffffffb948; WORD $0x000f // movabsq $4503599627370495, %rcx - WORD $0x2148; BYTE $0xd1 // andq %rdx, %rcx - WORD $0x0948; BYTE $0xc1 // orq %rax, %rcx + WORD $0x2148; BYTE $0xc1 // andq %rax, %rcx + WORD $0x0948; BYTE $0xd1 // orq %rdx, %rcx QUAD $0x000000000000b848; WORD $0x8000 // movabsq $-9223372036854775808, %rax WORD $0x0948; BYTE $0xc8 // orq %rcx, %rax LONG $0xfff98341 // cmpl $-1, %r9d LONG $0xc1450f48 // cmovneq %rcx, %rax WORD $0x8949; BYTE $0x00 // movq %rax, (%r8) WORD $0x01b0 // movb $1, %al - LONG $0xffffb8e9; BYTE $0xff // jmp LBB12_20, $-72(%rip) - QUAD $0x9090909090909090 // .p2align 4, 0x90 + LONG $0xffffb7e9; BYTE $0xff // jmp LBB8_19, $-73(%rip) + LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 _decimal_to_f64: BYTE $0x55 // pushq %rbp @@ -3342,284 +3062,262 @@ _decimal_to_f64: WORD $0x8949; BYTE $0xff // movq %rdi, %r15 QUAD $0x000000000000bd49; WORD $0x0010 // movabsq $4503599627370496, %r13 LONG $0x00107f83 // cmpl $0, $16(%rdi) - LONG $0x0021840f; WORD $0x0000 // je LBB13_3, $33(%rip) + LONG $0x002f840f; WORD $0x0000 // je LBB9_4, $47(%rip) + QUAD $0x000000000000be49; WORD $0x7ff0 // movabsq $9218868437227405312, %r14 LONG $0x14478b41 // movl $20(%r15), %eax - LONG $0x0001363d; BYTE $0x00 // cmpl $310, %eax - LONG $0x001d8e0f; WORD $0x0000 // jle LBB13_4, $29(%rip) - -LBB13_2: WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d - QUAD $0x000000000000be49; WORD $0x7ff0 // movabsq $9218868437227405312, %r14 - LONG $0x000397e9; BYTE $0x00 // jmp LBB13_69, $919(%rip) + LONG $0x0001363d; BYTE $0x00 // cmpl $310, %eax + LONG $0x034c8f0f; WORD $0x0000 // jg LBB9_64, $844(%rip) + LONG $0xfffeb63d; BYTE $0xff // cmpl $-330, %eax + LONG $0x00138d0f; WORD $0x0000 // jge LBB9_5, $19(%rip) + WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d + LONG $0x000339e9; BYTE $0x00 // jmp LBB9_64, $825(%rip) -LBB13_3: +LBB9_4: WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d - LONG $0x00038ce9; BYTE $0x00 // jmp LBB13_69, $908(%rip) + LONG $0x00032ee9; BYTE $0x00 // jmp LBB9_64, $814(%rip) -LBB13_4: - WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d - LONG $0xfffeb63d; BYTE $0xff // cmpl $-330, %eax - LONG $0x00088d0f; WORD $0x0000 // jge LBB13_6, $8(%rip) - WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d - LONG $0x000376e9; BYTE $0x00 // jmp LBB13_69, $886(%rip) - -LBB13_6: - WORD $0xc085 // testl %eax, %eax - LONG $0xd05d8948 // movq %rbx, $-48(%rbp) - LONG $0x00aa8e0f; WORD $0x0000 // jle LBB13_17, $170(%rip) - WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d - LONG $0x10358d4c; WORD $0x0088; BYTE $0x00 // leaq $34832(%rip), %r14 /* _POW_TAB(%rip) */ - LONG $0x000039e9; BYTE $0x00 // jmp LBB13_11, $57(%rip) - QUAD $0x9090909090909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 +LBB9_5: + WORD $0xc085 // testl %eax, %eax + LONG $0xd05d8948 // movq %rbx, $-48(%rbp) + LONG $0x005a8e0f; WORD $0x0000 // jle LBB9_12, $90(%rip) + WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d + LONG $0x68358d4c; WORD $0x0093; BYTE $0x00 // leaq $37736(%rip), %r14 /* _POW_TAB(%rip) */ + LONG $0x00002de9; BYTE $0x00 // jmp LBB9_8, $45(%rip) + WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 -LBB13_8: - LONG $0xffffe5be; BYTE $0xff // movl $-27, %esi - LONG $0x00001bbb; BYTE $0x00 // movl $27, %ebx +LBB9_10: + WORD $0xc089 // movl %eax, %eax + LONG $0x861c8b41 // movl (%r14,%rax,4), %ebx LONG $0x107f8341; BYTE $0x00 // cmpl $0, $16(%r15) - LONG $0x000a840f; WORD $0x0000 // je LBB13_10, $10(%rip) + LONG $0x000a840f; WORD $0x0000 // je LBB9_7, $10(%rip) -LBB13_9: - WORD $0xdef7 // negl %esi +LBB9_11: WORD $0x894c; BYTE $0xff // movq %r15, %rdi - LONG $0x0053f1e8; BYTE $0x00 // callq _right_shift, $21489(%rip) + WORD $0xde89 // movl %ebx, %esi + LONG $0x006265e8; BYTE $0x00 // callq _right_shift, $25189(%rip) -LBB13_10: +LBB9_7: WORD $0x0141; BYTE $0xdc // addl %ebx, %r12d LONG $0x14478b41 // movl $20(%r15), %eax WORD $0xc085 // testl %eax, %eax - LONG $0x00628e0f; WORD $0x0000 // jle LBB13_17, $98(%rip) + LONG $0x001e8e0f; WORD $0x0000 // jle LBB9_12, $30(%rip) -LBB13_11: +LBB9_8: WORD $0xf883; BYTE $0x08 // cmpl $8, %eax - LONG $0xffc9870f; WORD $0xffff // ja LBB13_8, $-55(%rip) - WORD $0xc089 // movl %eax, %eax - LONG $0x861c8b41 // movl (%r14,%rax,4), %ebx + LONG $0xffcd8e0f; WORD $0xffff // jle LBB9_10, $-51(%rip) + LONG $0x00001bbb; BYTE $0x00 // movl $27, %ebx LONG $0x107f8341; BYTE $0x00 // cmpl $0, $16(%r15) - LONG $0xffd7840f; WORD $0xffff // je LBB13_10, $-41(%rip) - WORD $0xde89 // movl %ebx, %esi - WORD $0xdef7 // negl %esi - WORD $0xfe83; BYTE $0xc3 // cmpl $-61, %esi - LONG $0xffc0870f; WORD $0xffff // ja LBB13_9, $-64(%rip) - WORD $0x894d; BYTE $0xf5 // movq %r14, %r13 - QUAD $0x9090909090909090 // .p2align 4, 0x90 - -LBB13_15: - WORD $0x8941; BYTE $0xf6 // movl %esi, %r14d - WORD $0x894c; BYTE $0xff // movq %r15, %rdi - LONG $0x00003cbe; BYTE $0x00 // movl $60, %esi - LONG $0x0053a0e8; BYTE $0x00 // callq _right_shift, $21408(%rip) - LONG $0x3c768d41 // leal $60(%r14), %esi - LONG $0x88fe8341 // cmpl $-120, %r14d - LONG $0xffe2820f; WORD $0xffff // jb LBB13_15, $-30(%rip) - WORD $0x894d; BYTE $0xee // movq %r13, %r14 - QUAD $0x000000000000bd49; WORD $0x0010 // movabsq $4503599627370496, %r13 - LONG $0xffff85e9; BYTE $0xff // jmp LBB13_9, $-123(%rip) + LONG $0xffce850f; WORD $0xffff // jne LBB9_11, $-50(%rip) + LONG $0xffffd3e9; BYTE $0xff // jmp LBB9_7, $-45(%rip) -LBB13_17: - LONG $0x69358d4c; WORD $0x0087; BYTE $0x00 // leaq $34665(%rip), %r14 /* _POW_TAB(%rip) */ - LONG $0x000025e9; BYTE $0x00 // jmp LBB13_19, $37(%rip) +LBB9_12: + LONG $0x11358d4c; WORD $0x0093; BYTE $0x00 // leaq $37649(%rip), %r14 /* _POW_TAB(%rip) */ + LONG $0x00002de9; BYTE $0x00 // jmp LBB9_14, $45(%rip) -LBB13_23: - LONG $0x00001bbb; BYTE $0x00 // movl $27, %ebx - LONG $0x107f8341; BYTE $0x00 // cmpl $0, $16(%r15) - LONG $0x0012840f; WORD $0x0000 // je LBB13_18, $18(%rip) - LONG $0x90909090 // .p2align 4, 0x90 +LBB9_18: + LONG $0x00001bbb; BYTE $0x00 // movl $27, %ebx + LONG $0x107f8341; BYTE $0x00 // cmpl $0, $16(%r15) + LONG $0x001a840f; WORD $0x0000 // je LBB9_13, $26(%rip) + QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90 -LBB13_25: +LBB9_20: WORD $0x894c; BYTE $0xff // movq %r15, %rdi WORD $0xde89 // movl %ebx, %esi - LONG $0x005166e8; BYTE $0x00 // callq _left_shift, $20838(%rip) + LONG $0x006016e8; BYTE $0x00 // callq _left_shift, $24598(%rip) LONG $0x14478b41 // movl $20(%r15), %eax -LBB13_18: +LBB9_13: WORD $0x2941; BYTE $0xdc // subl %ebx, %r12d -LBB13_19: +LBB9_14: WORD $0xc085 // testl %eax, %eax - LONG $0x0017880f; WORD $0x0000 // js LBB13_22, $23(%rip) - LONG $0x0032850f; WORD $0x0000 // jne LBB13_26, $50(%rip) + LONG $0x0017880f; WORD $0x0000 // js LBB9_17, $23(%rip) + LONG $0x0035850f; WORD $0x0000 // jne LBB9_21, $53(%rip) WORD $0x8b49; BYTE $0x0f // movq (%r15), %rcx WORD $0x3980; BYTE $0x35 // cmpb $53, (%rcx) - LONG $0x000e8c0f; WORD $0x0000 // jl LBB13_24, $14(%rip) - LONG $0x000021e9; BYTE $0x00 // jmp LBB13_26, $33(%rip) + LONG $0x000e8c0f; WORD $0x0000 // jl LBB9_19, $14(%rip) + LONG $0x000024e9; BYTE $0x00 // jmp LBB9_21, $36(%rip) // .p2align 4, 0x90 -LBB13_22: +LBB9_17: WORD $0xf883; BYTE $0xf8 // cmpl $-8, %eax - LONG $0xffb3820f; WORD $0xffff // jb LBB13_23, $-77(%rip) + LONG $0xffab8c0f; WORD $0xffff // jl LBB9_18, $-85(%rip) -LBB13_24: +LBB9_19: WORD $0xc189 // movl %eax, %ecx WORD $0xd9f7 // negl %ecx + WORD $0x6348; BYTE $0xc9 // movslq %ecx, %rcx LONG $0x8e1c8b41 // movl (%r14,%rcx,4), %ebx LONG $0x107f8341; BYTE $0x00 // cmpl $0, $16(%r15) - LONG $0xffb4850f; WORD $0xffff // jne LBB13_25, $-76(%rip) - LONG $0xffffbde9; BYTE $0xff // jmp LBB13_18, $-67(%rip) - -LBB13_26: - LONG $0x02fc8141; WORD $0xfffc; BYTE $0xff // cmpl $-1022, %r12d - LONG $0x00568f0f; WORD $0x0000 // jg LBB13_32, $86(%rip) - LONG $0x107f8341; BYTE $0x00 // cmpl $0, $16(%r15) - LONG $0xd05d8b48 // movq $-48(%rbp), %rbx - LONG $0x0075840f; WORD $0x0000 // je LBB13_35, $117(%rip) - LONG $0xc6fc8141; WORD $0xfffb; BYTE $0xff // cmpl $-1082, %r12d - LONG $0x0073870f; WORD $0x0000 // ja LBB13_36, $115(%rip) - LONG $0xc1c48141; WORD $0x0003; BYTE $0x00 // addl $961, %r12d - QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + LONG $0xffb1850f; WORD $0xffff // jne LBB9_20, $-79(%rip) + LONG $0xffffbae9; BYTE $0xff // jmp LBB9_13, $-70(%rip) + +LBB9_21: + LONG $0x02fc8141; WORD $0xfffc; BYTE $0xff // cmpl $-1022, %r12d + LONG $0x00538f0f; WORD $0x0000 // jg LBB9_27, $83(%rip) + LONG $0x107f8341; BYTE $0x00 // cmpl $0, $16(%r15) + LONG $0xd05d8b48 // movq $-48(%rbp), %rbx + LONG $0x0060840f; WORD $0x0000 // je LBB9_29, $96(%rip) + LONG $0xc6fc8141; WORD $0xfffb; BYTE $0xff // cmpl $-1082, %r12d + LONG $0x005e8f0f; WORD $0x0000 // jg LBB9_30, $94(%rip) + LONG $0xc1c48141; WORD $0x0003; BYTE $0x00 // addl $961, %r12d + QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90 -LBB13_30: +LBB9_25: WORD $0x894c; BYTE $0xff // movq %r15, %rdi LONG $0x00003cbe; BYTE $0x00 // movl $60, %esi - LONG $0x0052c3e8; BYTE $0x00 // callq _right_shift, $21187(%rip) + LONG $0x006173e8; BYTE $0x00 // callq _right_shift, $24947(%rip) LONG $0x3cc48341 // addl $60, %r12d LONG $0x88fc8341 // cmpl $-120, %r12d - LONG $0xffe5820f; WORD $0xffff // jb LBB13_30, $-27(%rip) + LONG $0xffe58c0f; WORD $0xffff // jl LBB9_25, $-27(%rip) LONG $0x3cc48341 // addl $60, %r12d - LONG $0x000040e9; BYTE $0x00 // jmp LBB13_37, $64(%rip) + LONG $0x00002ee9; BYTE $0x00 // jmp LBB9_31, $46(%rip) -LBB13_32: +LBB9_27: LONG $0x00fc8141; WORD $0x0004; BYTE $0x00 // cmpl $1024, %r12d LONG $0xd05d8b48 // movq $-48(%rbp), %rbx - QUAD $0x000000000000be49; WORD $0x7ff0 // movabsq $9218868437227405312, %r14 - LONG $0x00088e0f; WORD $0x0000 // jle LBB13_34, $8(%rip) - WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d - LONG $0x0001c9e9; BYTE $0x00 // jmp LBB13_69, $457(%rip) - -LBB13_34: - WORD $0xff41; BYTE $0xcc // decl %r12d - WORD $0x8945; BYTE $0xe6 // movl %r12d, %r14d - LONG $0x000026e9; BYTE $0x00 // jmp LBB13_38, $38(%rip) + LONG $0x01a48f0f; WORD $0x0000 // jg LBB9_61, $420(%rip) + WORD $0xff41; BYTE $0xcc // decl %r12d + WORD $0x8945; BYTE $0xe6 // movl %r12d, %r14d + LONG $0x000026e9; BYTE $0x00 // jmp LBB9_32, $38(%rip) -LBB13_35: +LBB9_29: LONG $0xfc02be41; WORD $0xffff // movl $-1022, %r14d - LONG $0x000033e9; BYTE $0x00 // jmp LBB13_40, $51(%rip) + LONG $0x000033e9; BYTE $0x00 // jmp LBB9_34, $51(%rip) -LBB13_36: +LBB9_30: LONG $0xfdc48141; WORD $0x0003; BYTE $0x00 // addl $1021, %r12d -LBB13_37: +LBB9_31: WORD $0xf741; BYTE $0xdc // negl %r12d WORD $0x894c; BYTE $0xff // movq %r15, %rdi WORD $0x8944; BYTE $0xe6 // movl %r12d, %esi - LONG $0x00525ee8; BYTE $0x00 // callq _right_shift, $21086(%rip) + LONG $0x006120e8; BYTE $0x00 // callq _right_shift, $24864(%rip) LONG $0xfc02be41; WORD $0xffff // movl $-1022, %r14d -LBB13_38: +LBB9_32: LONG $0x107f8341; BYTE $0x00 // cmpl $0, $16(%r15) - LONG $0x000d840f; WORD $0x0000 // je LBB13_40, $13(%rip) + LONG $0x000d840f; WORD $0x0000 // je LBB9_34, $13(%rip) WORD $0x894c; BYTE $0xff // movq %r15, %rdi LONG $0x000035be; BYTE $0x00 // movl $53, %esi - LONG $0x005050e8; BYTE $0x00 // callq _left_shift, $20560(%rip) + LONG $0x005f12e8; BYTE $0x00 // callq _left_shift, $24338(%rip) -LBB13_40: +LBB9_34: LONG $0x14478b41 // movl $20(%r15), %eax LONG $0xffc4c749; WORD $0xffff; BYTE $0xff // movq $-1, %r12 WORD $0xf883; BYTE $0x14 // cmpl $20, %eax - LONG $0x014d8f0f; WORD $0x0000 // jg LBB13_68, $333(%rip) + LONG $0x015f8f0f; WORD $0x0000 // jg LBB9_63, $351(%rip) WORD $0xc085 // testl %eax, %eax - LONG $0x00558e0f; WORD $0x0000 // jle LBB13_46, $85(%rip) + LONG $0x00548e0f; WORD $0x0000 // jle LBB9_40, $84(%rip) LONG $0x10578b41 // movl $16(%r15), %edx WORD $0xf631 // xorl %esi, %esi WORD $0xd285 // testl %edx, %edx - WORD $0x4e0f; BYTE $0xd6 // cmovlel %esi, %edx + WORD $0x480f; BYTE $0xd6 // cmovsl %esi, %edx LONG $0xff488d4c // leaq $-1(%rax), %r9 WORD $0x3949; BYTE $0xd1 // cmpq %rdx, %r9 - LONG $0xca430f4c // cmovaeq %rdx, %r9 - LONG $0x01418d4d // leaq $1(%r9), %r8 + LONG $0xca430f44 // cmovael %edx, %r9d + LONG $0x01418d45 // leal $1(%r9), %r8d WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d - LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90 -LBB13_43: +LBB9_37: WORD $0x3948; BYTE $0xf2 // cmpq %rsi, %rdx - LONG $0x002e840f; WORD $0x0000 // je LBB13_47, $46(%rip) + LONG $0x002b840f; WORD $0x0000 // je LBB9_41, $43(%rip) LONG $0xa43c8d4b // leaq (%r12,%r12,4), %rdi WORD $0x8b49; BYTE $0x0f // movq (%r15), %rcx LONG $0x0cbe0f48; BYTE $0x31 // movsbq (%rcx,%rsi), %rcx - LONG $0x79248d4c // leaq (%rcx,%rdi,2), %r12 - LONG $0xd0c48349 // addq $-48, %r12 + LONG $0x79648d4c; BYTE $0xd0 // leaq $-48(%rcx,%rdi,2), %r12 WORD $0xff48; BYTE $0xc6 // incq %rsi WORD $0x3948; BYTE $0xf0 // cmpq %rsi, %rax - LONG $0xffd7850f; WORD $0xffff // jne LBB13_43, $-41(%rip) - WORD $0x894d; BYTE $0xc1 // movq %r8, %r9 - LONG $0x000006e9; BYTE $0x00 // jmp LBB13_47, $6(%rip) + LONG $0xffda850f; WORD $0xffff // jne LBB9_37, $-38(%rip) + WORD $0x8945; BYTE $0xc1 // movl %r8d, %r9d + LONG $0x000006e9; BYTE $0x00 // jmp LBB9_41, $6(%rip) -LBB13_46: +LBB9_40: WORD $0x3145; BYTE $0xc9 // xorl %r9d, %r9d WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d -LBB13_47: - WORD $0x3944; BYTE $0xc8 // cmpl %r9d, %eax - LONG $0x00608e0f; WORD $0x0000 // jle LBB13_55, $96(%rip) - WORD $0xc689 // movl %eax, %esi - WORD $0x2944; BYTE $0xce // subl %r9d, %esi - WORD $0x8944; BYTE $0xca // movl %r9d, %edx - WORD $0xd2f7 // notl %edx - WORD $0xc201 // addl %eax, %edx - WORD $0xe683; BYTE $0x07 // andl $7, %esi - LONG $0x001f840f; WORD $0x0000 // je LBB13_52, $31(%rip) - WORD $0xdef7 // negl %esi - WORD $0xff31 // xorl %edi, %edi - LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 +LBB9_41: + WORD $0x3944; BYTE $0xc8 // cmpl %r9d, %eax + LONG $0x00638e0f; WORD $0x0000 // jle LBB9_49, $99(%rip) + WORD $0xc689 // movl %eax, %esi + WORD $0x2944; BYTE $0xce // subl %r9d, %esi + WORD $0x8944; BYTE $0xca // movl %r9d, %edx + WORD $0xd2f7 // notl %edx + WORD $0xc201 // addl %eax, %edx + WORD $0xe683; BYTE $0x07 // andl $7, %esi + LONG $0x0022840f; WORD $0x0000 // je LBB9_46, $34(%rip) + WORD $0xdef7 // negl %esi + WORD $0xff31 // xorl %edi, %edi + QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90 -LBB13_50: +LBB9_44: WORD $0x014d; BYTE $0xe4 // addq %r12, %r12 LONG $0xa4248d4f // leaq (%r12,%r12,4), %r12 WORD $0xcfff // decl %edi WORD $0xfe39 // cmpl %edi, %esi - LONG $0xffef850f; WORD $0xffff // jne LBB13_50, $-17(%rip) + LONG $0xffef850f; WORD $0xffff // jne LBB9_44, $-17(%rip) WORD $0x2941; BYTE $0xf9 // subl %edi, %r9d -LBB13_52: +LBB9_46: WORD $0xfa83; BYTE $0x07 // cmpl $7, %edx - LONG $0x0023820f; WORD $0x0000 // jb LBB13_55, $35(%rip) + LONG $0x0023820f; WORD $0x0000 // jb LBB9_49, $35(%rip) WORD $0xc289 // movl %eax, %edx WORD $0x2944; BYTE $0xca // subl %r9d, %edx QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 -LBB13_54: +LBB9_48: LONG $0x00e4694d; WORD $0xf5e1; BYTE $0x05 // imulq $100000000, %r12, %r12 WORD $0xc283; BYTE $0xf8 // addl $-8, %edx - LONG $0xfff0850f; WORD $0xffff // jne LBB13_54, $-16(%rip) + LONG $0xfff0850f; WORD $0xffff // jne LBB9_48, $-16(%rip) -LBB13_55: +LBB9_49: WORD $0xc085 // testl %eax, %eax - LONG $0x004b880f; WORD $0x0000 // js LBB13_62, $75(%rip) - LONG $0x10578b41 // movl $16(%r15), %edx - WORD $0xc239 // cmpl %eax, %edx - LONG $0x003f8e0f; WORD $0x0000 // jle LBB13_62, $63(%rip) - WORD $0x8b49; BYTE $0x37 // movq (%r15), %rsi - LONG $0x060cb60f // movzbl (%rsi,%rax), %ecx - WORD $0xf980; BYTE $0x35 // cmpb $53, %cl - LONG $0x00af850f; WORD $0x0000 // jne LBB13_64, $175(%rip) + LONG $0x0049880f; WORD $0x0000 // js LBB9_57, $73(%rip) + LONG $0x10778b41 // movl $16(%r15), %esi + WORD $0xc639 // cmpl %eax, %esi + LONG $0x003d8e0f; WORD $0x0000 // jle LBB9_57, $61(%rip) + WORD $0x8b49; BYTE $0x17 // movq (%r15), %rdx + WORD $0x0c8a; BYTE $0x02 // movb (%rdx,%rax), %cl WORD $0x788d; BYTE $0x01 // leal $1(%rax), %edi - WORD $0xd739 // cmpl %edx, %edi - LONG $0x00a4850f; WORD $0x0000 // jne LBB13_64, $164(%rip) - WORD $0x01b2 // movb $1, %dl + WORD $0xf739 // cmpl %esi, %edi + LONG $0x00be850f; WORD $0x0000 // jne LBB9_58, $190(%rip) + WORD $0xf980; BYTE $0x35 // cmpb $53, %cl + LONG $0x00b5850f; WORD $0x0000 // jne LBB9_58, $181(%rip) LONG $0x1c7f8341; BYTE $0x00 // cmpl $0, $28(%r15) - LONG $0x0019850f; WORD $0x0000 // jne LBB13_65, $25(%rip) - WORD $0x8548; BYTE $0xc0 // testq %rax, %rax - LONG $0x000e840f; WORD $0x0000 // je LBB13_62, $14(%rip) + WORD $0x950f; BYTE $0xc1 // setne %cl + LONG $0x0017850f; WORD $0x0000 // jne LBB9_59, $23(%rip) + WORD $0xc085 // testl %eax, %eax + LONG $0x000f8e0f; WORD $0x0000 // jle LBB9_59, $15(%rip) WORD $0xc8ff // decl %eax - LONG $0x0614b60f // movzbl (%rsi,%rax), %edx - WORD $0xe280; BYTE $0x01 // andb $1, %dl - LONG $0x000002e9; BYTE $0x00 // jmp LBB13_65, $2(%rip) + WORD $0x0c8a; BYTE $0x02 // movb (%rdx,%rax), %cl + WORD $0xe180; BYTE $0x01 // andb $1, %cl + LONG $0x000002e9; BYTE $0x00 // jmp LBB9_59, $2(%rip) -LBB13_62: - WORD $0xd231 // xorl %edx, %edx +LBB9_57: + WORD $0xc931 // xorl %ecx, %ecx -LBB13_65: - WORD $0xb60f; BYTE $0xc2 // movzbl %dl, %eax +LBB9_59: + WORD $0xb60f; BYTE $0xc1 // movzbl %cl, %eax WORD $0x0149; BYTE $0xc4 // addq %rax, %r12 QUAD $0x000000000000b848; WORD $0x0020 // movabsq $9007199254740992, %rax WORD $0x3949; BYTE $0xc4 // cmpq %rax, %r12 - LONG $0x0013850f; WORD $0x0000 // jne LBB13_68, $19(%rip) + LONG $0x0025850f; WORD $0x0000 // jne LBB9_63, $37(%rip) LONG $0xfefe8141; WORD $0x0003; BYTE $0x00 // cmpl $1022, %r14d - LONG $0xfc7c8f0f; WORD $0xffff // jg LBB13_2, $-900(%rip) - WORD $0xff41; BYTE $0xc6 // incl %r14d - WORD $0x894d; BYTE $0xec // movq %r13, %r12 + LONG $0x00128e0f; WORD $0x0000 // jle LBB9_62, $18(%rip) -LBB13_68: +LBB9_61: + WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d + QUAD $0x000000000000be49; WORD $0x7ff0 // movabsq $9218868437227405312, %r14 + LONG $0x000025e9; BYTE $0x00 // jmp LBB9_64, $37(%rip) + +LBB9_62: + WORD $0xff41; BYTE $0xc6 // incl %r14d + WORD $0x894d; BYTE $0xec // movq %r13, %r12 + +LBB9_63: WORD $0x894c; BYTE $0xe0 // movq %r12, %rax WORD $0x214c; BYTE $0xe8 // andq %r13, %rax LONG $0xffc68141; WORD $0x0003; BYTE $0x00 // addl $1023, %r14d @@ -3628,7 +3326,7 @@ LBB13_68: WORD $0x8548; BYTE $0xc0 // testq %rax, %rax LONG $0xf0440f4c // cmoveq %rax, %r14 -LBB13_69: +LBB9_64: WORD $0xff49; BYTE $0xcd // decq %r13 WORD $0x214d; BYTE $0xe5 // andq %r12, %r13 WORD $0x094d; BYTE $0xf5 // orq %r14, %r13 @@ -3647,933 +3345,741 @@ LBB13_69: BYTE $0x5d // popq %rbp BYTE $0xc3 // retq -LBB13_64: - WORD $0xf980; BYTE $0x35 // cmpb $53, %cl - WORD $0x9d0f; BYTE $0xc2 // setge %dl - LONG $0xffff77e9; BYTE $0xff // jmp LBB13_65, $-137(%rip) +LBB9_58: + WORD $0xf980; BYTE $0x34 // cmpb $52, %cl + WORD $0x9f0f; BYTE $0xc1 // setg %cl + LONG $0xffff65e9; BYTE $0xff // jmp LBB9_59, $-155(%rip) WORD $0x9090 // .p2align 4, 0x90 _atof_native: - BYTE $0x55 // pushq %rbp - WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp - WORD $0x5741 // pushq %r15 - WORD $0x5641 // pushq %r14 - WORD $0x5541 // pushq %r13 - WORD $0x5441 // pushq %r12 - BYTE $0x53 // pushq %rbx - LONG $0x28ec8348 // subq $40, %rsp - QUAD $0x00000000d045c748 // movq $0, $-48(%rbp) - LONG $0xb0558948 // movq %rdx, $-80(%rbp) - LONG $0xb84d8948 // movq %rcx, $-72(%rbp) - WORD $0x8548; BYTE $0xc9 // testq %rcx, %rcx - LONG $0x0126840f; WORD $0x0000 // je LBB14_18, $294(%rip) - LONG $0x08f98348 // cmpq $8, %rcx - LONG $0x0007830f; WORD $0x0000 // jae LBB14_3, $7(%rip) - WORD $0xdb31 // xorl %ebx, %ebx - LONG $0x000105e9; BYTE $0x00 // jmp LBB14_17, $261(%rip) - -LBB14_3: - LONG $0x20f98348 // cmpq $32, %rcx - LONG $0x0007830f; WORD $0x0000 // jae LBB14_5, $7(%rip) - WORD $0xdb31 // xorl %ebx, %ebx - LONG $0x0000bee9; BYTE $0x00 // jmp LBB14_14, $190(%rip) + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + LONG $0x30ec8348 // subq $48, %rsp + QUAD $0x00000000d845c748 // movq $0, $-40(%rbp) + LONG $0xe0558948 // movq %rdx, $-32(%rbp) + LONG $0xe84d8948 // movq %rcx, $-24(%rbp) + WORD $0x8548; BYTE $0xc9 // testq %rcx, %rcx + LONG $0x0044840f; WORD $0x0000 // je LBB10_5, $68(%rip) + WORD $0x02c6; BYTE $0x00 // movb $0, (%rdx) + LONG $0x01f98348 // cmpq $1, %rcx + LONG $0x0037840f; WORD $0x0000 // je LBB10_5, $55(%rip) + LONG $0x000142c6 // movb $0, $1(%rdx) + LONG $0xe87d8348; BYTE $0x03 // cmpq $3, $-24(%rbp) + LONG $0x0028820f; WORD $0x0000 // jb LBB10_5, $40(%rip) + LONG $0x000002b8; BYTE $0x00 // movl $2, %eax + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 -LBB14_5: - WORD $0x8948; BYTE $0xcb // movq %rcx, %rbx - LONG $0xe0e38348 // andq $-32, %rbx - LONG $0xe0438d48 // leaq $-32(%rbx), %rax - WORD $0x8949; BYTE $0xc1 // movq %rax, %r9 - LONG $0x05e9c149 // shrq $5, %r9 - WORD $0xff49; BYTE $0xc1 // incq %r9 - WORD $0x8945; BYTE $0xc8 // movl %r9d, %r8d - LONG $0x03e08341 // andl $3, %r8d - LONG $0x60f88348 // cmpq $96, %rax - LONG $0x0007830f; WORD $0x0000 // jae LBB14_7, $7(%rip) - WORD $0xc031 // xorl %eax, %eax - LONG $0x00004ce9; BYTE $0x00 // jmp LBB14_9, $76(%rip) +LBB10_4: + LONG $0xe04d8b48 // movq $-32(%rbp), %rcx + LONG $0x000104c6 // movb $0, (%rcx,%rax) + WORD $0xff48; BYTE $0xc0 // incq %rax + LONG $0xe8453948 // cmpq %rax, $-24(%rbp) + LONG $0xffeb870f; WORD $0xffff // ja LBB10_4, $-21(%rip) -LBB14_7: - LONG $0xfce18349 // andq $-4, %r9 - WORD $0xc031 // xorl %eax, %eax - WORD $0x570f; BYTE $0xc0 // xorps %xmm0, %xmm0 - QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 +LBB10_5: + WORD $0x570f; BYTE $0xc0 // xorps %xmm0, %xmm0 + LONG $0xf045110f // movups %xmm0, $-16(%rbp) + WORD $0x3f80; BYTE $0x2d // cmpb $45, (%rdi) + LONG $0x0021850f; WORD $0x0000 // jne LBB10_8, $33(%rip) + LONG $0x01f845c7; WORD $0x0000; BYTE $0x00 // movl $1, $-8(%rbp) + LONG $0x000001b8; BYTE $0x00 // movl $1, %eax + WORD $0x3948; BYTE $0xf0 // cmpq %rsi, %rax + LONG $0x00178c0f; WORD $0x0000 // jl LBB10_9, $23(%rip) -LBB14_8: - LONG $0x0204110f // movups %xmm0, (%rdx,%rax) - LONG $0x0244110f; BYTE $0x10 // movups %xmm0, $16(%rdx,%rax) - LONG $0x0244110f; BYTE $0x20 // movups %xmm0, $32(%rdx,%rax) - LONG $0x0244110f; BYTE $0x30 // movups %xmm0, $48(%rdx,%rax) - LONG $0x0244110f; BYTE $0x40 // movups %xmm0, $64(%rdx,%rax) - LONG $0x0244110f; BYTE $0x50 // movups %xmm0, $80(%rdx,%rax) - LONG $0x0244110f; BYTE $0x60 // movups %xmm0, $96(%rdx,%rax) - LONG $0x0244110f; BYTE $0x70 // movups %xmm0, $112(%rdx,%rax) - LONG $0x80e88348 // subq $-128, %rax - LONG $0xfcc18349 // addq $-4, %r9 - LONG $0xffcb850f; WORD $0xffff // jne LBB14_8, $-53(%rip) +LBB10_7: + LONG $0x00f445c7; WORD $0x0000; BYTE $0x00 // movl $0, $-12(%rbp) + LONG $0x0001a3e9; BYTE $0x00 // jmp LBB10_39, $419(%rip) -LBB14_9: - WORD $0x854d; BYTE $0xc0 // testq %r8, %r8 - LONG $0x002a840f; WORD $0x0000 // je LBB14_12, $42(%rip) - LONG $0x100c8d4c // leaq (%rax,%rdx), %r9 - LONG $0x10c18349 // addq $16, %r9 - LONG $0x05e0c149 // shlq $5, %r8 +LBB10_8: WORD $0xc031 // xorl %eax, %eax - WORD $0x570f; BYTE $0xc0 // xorps %xmm0, %xmm0 - BYTE $0x90 // .p2align 4, 0x90 - -LBB14_11: - LONG $0x44110f41; WORD $0xf001 // movups %xmm0, $-16(%r9,%rax) - LONG $0x04110f41; BYTE $0x01 // movups %xmm0, (%r9,%rax) - LONG $0x20c08348 // addq $32, %rax - WORD $0x3949; BYTE $0xc0 // cmpq %rax, %r8 - LONG $0xffe8850f; WORD $0xffff // jne LBB14_11, $-24(%rip) + WORD $0x3948; BYTE $0xf0 // cmpq %rsi, %rax + LONG $0xffe98d0f; WORD $0xffff // jge LBB10_7, $-23(%rip) -LBB14_12: - WORD $0x3948; BYTE $0xcb // cmpq %rcx, %rbx - LONG $0x004f840f; WORD $0x0000 // je LBB14_18, $79(%rip) - WORD $0xc1f6; BYTE $0x18 // testb $24, %cl - LONG $0x0036840f; WORD $0x0000 // je LBB14_17, $54(%rip) +LBB10_9: + WORD $0xb341; BYTE $0x01 // movb $1, %r11b + WORD $0x3145; BYTE $0xc9 // xorl %r9d, %r9d + WORD $0x3145; BYTE $0xd2 // xorl %r10d, %r10d + WORD $0x3145; BYTE $0xc0 // xorl %r8d, %r8d + LONG $0x000021e9; BYTE $0x00 // jmp LBB10_13, $33(%rip) -LBB14_14: - WORD $0x8948; BYTE $0xd8 // movq %rbx, %rax - WORD $0x8948; BYTE $0xcb // movq %rcx, %rbx - LONG $0xf8e38348 // andq $-8, %rbx - QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90 +LBB10_21: + LONG $0x01fc45c7; WORD $0x0000; BYTE $0x00 // movl $1, $-4(%rbp) + LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 -LBB14_15: - QUAD $0x000000000204c748 // movq $0, (%rdx,%rax) - LONG $0x08c08348 // addq $8, %rax - WORD $0x3948; BYTE $0xc3 // cmpq %rax, %rbx - LONG $0xffeb850f; WORD $0xffff // jne LBB14_15, $-21(%rip) - WORD $0x3948; BYTE $0xcb // cmpq %rcx, %rbx - LONG $0x0012840f; WORD $0x0000 // je LBB14_18, $18(%rip) - WORD $0x9090 // .p2align 4, 0x90 +LBB10_12: + WORD $0xff48; BYTE $0xc0 // incq %rax + WORD $0x3948; BYTE $0xf0 // cmpq %rsi, %rax + LONG $0xc39c0f41 // setl %r11b + WORD $0x3948; BYTE $0xc6 // cmpq %rax, %rsi + LONG $0x0090840f; WORD $0x0000 // je LBB10_23, $144(%rip) + +LBB10_13: + LONG $0x070cb60f // movzbl (%rdi,%rax), %ecx + WORD $0x518d; BYTE $0xd0 // leal $-48(%rcx), %edx + WORD $0xfa80; BYTE $0x09 // cmpb $9, %dl + LONG $0x002d870f; WORD $0x0000 // ja LBB10_18, $45(%rip) + WORD $0xf980; BYTE $0x30 // cmpb $48, %cl + LONG $0x0044850f; WORD $0x0000 // jne LBB10_20, $68(%rip) + WORD $0x8545; BYTE $0xd2 // testl %r10d, %r10d + LONG $0x0063840f; WORD $0x0000 // je LBB10_22, $99(%rip) + WORD $0x634d; BYTE $0xd9 // movslq %r9d, %r11 + LONG $0xe85d394c // cmpq %r11, $-24(%rbp) + LONG $0x003b870f; WORD $0x0000 // ja LBB10_10, $59(%rip) + LONG $0x000049e9; BYTE $0x00 // jmp LBB10_11, $73(%rip) + QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90 -LBB14_17: - LONG $0x001a04c6 // movb $0, (%rdx,%rbx) - WORD $0xff48; BYTE $0xc3 // incq %rbx - WORD $0x3948; BYTE $0xd9 // cmpq %rbx, %rcx - LONG $0xfff0850f; WORD $0xffff // jne LBB14_17, $-16(%rip) +LBB10_18: + WORD $0xf980; BYTE $0x2e // cmpb $46, %cl + LONG $0x009b850f; WORD $0x0000 // jne LBB10_30, $155(%rip) + LONG $0xf4558944 // movl %r10d, $-12(%rbp) + LONG $0x0001b841; WORD $0x0000 // movl $1, %r8d + LONG $0xffff98e9; BYTE $0xff // jmp LBB10_12, $-104(%rip) + QUAD $0x9090909090909090 // .p2align 4, 0x90 -LBB14_18: - LONG $0x00c045c7; WORD $0x0000; BYTE $0x00 // movl $0, $-64(%rbp) - QUAD $0x00000000c845c748 // movq $0, $-56(%rbp) - WORD $0x3145; BYTE $0xc0 // xorl %r8d, %r8d - WORD $0x3f80; BYTE $0x2d // cmpb $45, (%rdi) - LONG $0x001b850f; WORD $0x0000 // jne LBB14_19, $27(%rip) - LONG $0x01c845c7; WORD $0x0000; BYTE $0x00 // movl $1, $-56(%rbp) - LONG $0x0001bd41; WORD $0x0000 // movl $1, %r13d - WORD $0x3949; BYTE $0xf5 // cmpq %rsi, %r13 - LONG $0x00118c0f; WORD $0x0000 // jl LBB14_22, $17(%rip) - LONG $0x0001b6e9; BYTE $0x00 // jmp LBB14_54, $438(%rip) +LBB10_20: + WORD $0x634d; BYTE $0xda // movslq %r10d, %r11 + LONG $0xe85d394c // cmpq %r11, $-24(%rbp) + LONG $0xff75860f; WORD $0xffff // jbe LBB10_21, $-139(%rip) -LBB14_19: - WORD $0x3145; BYTE $0xed // xorl %r13d, %r13d - WORD $0x3949; BYTE $0xf5 // cmpq %rsi, %r13 - LONG $0x01aa8d0f; WORD $0x0000 // jge LBB14_54, $426(%rip) +LBB10_10: + LONG $0xe0558b48 // movq $-32(%rbp), %rdx + LONG $0x1a0c8842 // movb %cl, (%rdx,%r11) + LONG $0xf04d8b44 // movl $-16(%rbp), %r9d + WORD $0xff41; BYTE $0xc1 // incl %r9d + LONG $0xf04d8944 // movl %r9d, $-16(%rbp) -LBB14_22: - WORD $0xb741; BYTE $0x01 // movb $1, %r15b - WORD $0x3145; BYTE $0xc0 // xorl %r8d, %r8d - WORD $0x3145; BYTE $0xc9 // xorl %r9d, %r9d - WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d - WORD $0x3145; BYTE $0xdb // xorl %r11d, %r11d - WORD $0xdb31 // xorl %ebx, %ebx - LONG $0x000028e9; BYTE $0x00 // jmp LBB14_23, $40(%rip) - QUAD $0x9090909090909090 // .p2align 4, 0x90 +LBB10_11: + WORD $0x8945; BYTE $0xca // movl %r9d, %r10d + LONG $0xffff68e9; BYTE $0xff // jmp LBB10_12, $-152(%rip) -LBB14_33: - LONG $0x000001bb; BYTE $0x00 // movl $1, %ebx - WORD $0x8945; BYTE $0xdc // movl %r11d, %r12d - WORD $0x2e3c // cmpb $46, %al - LONG $0x0095850f; WORD $0x0000 // jne LBB14_36, $149(%rip) +LBB10_22: + WORD $0x4dff; BYTE $0xf4 // decl $-12(%rbp) + WORD $0x3145; BYTE $0xd2 // xorl %r10d, %r10d + LONG $0xffff5de9; BYTE $0xff // jmp LBB10_12, $-163(%rip) -LBB14_34: - WORD $0xff49; BYTE $0xc5 // incq %r13 - WORD $0x3949; BYTE $0xf5 // cmpq %rsi, %r13 - LONG $0xc79c0f41 // setl %r15b - LONG $0x007c840f; WORD $0x0000 // je LBB14_35, $124(%rip) +LBB10_23: + WORD $0xf189 // movl %esi, %ecx + WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax + WORD $0x8545; BYTE $0xc0 // testl %r8d, %r8d + LONG $0x0004850f; WORD $0x0000 // jne LBB10_25, $4(%rip) + +LBB10_24: + LONG $0xf44d8944 // movl %r9d, $-12(%rbp) + +LBB10_25: + LONG $0x01c3f641 // testb $1, %r11b + LONG $0x00ba840f; WORD $0x0000 // je LBB10_39, $186(%rip) + WORD $0x0c8a; BYTE $0x0f // movb (%rdi,%rcx), %cl + WORD $0xc980; BYTE $0x20 // orb $32, %cl + WORD $0xf980; BYTE $0x65 // cmpb $101, %cl + LONG $0x00ab850f; WORD $0x0000 // jne LBB10_39, $171(%rip) + WORD $0xc289 // movl %eax, %edx + LONG $0x01174c8a // movb $1(%rdi,%rdx), %cl + WORD $0xf980; BYTE $0x2d // cmpb $45, %cl + LONG $0x0028840f; WORD $0x0000 // je LBB10_31, $40(%rip) + LONG $0x0001b841; WORD $0x0000 // movl $1, %r8d + WORD $0xf980; BYTE $0x2b // cmpb $43, %cl + LONG $0x0038850f; WORD $0x0000 // jne LBB10_33, $56(%rip) + WORD $0xc083; BYTE $0x02 // addl $2, %eax + LONG $0x00001ae9; BYTE $0x00 // jmp LBB10_32, $26(%rip) + +LBB10_30: + WORD $0x8948; BYTE $0xc1 // movq %rax, %rcx + WORD $0x8545; BYTE $0xc0 // testl %r8d, %r8d + LONG $0xffb5850f; WORD $0xffff // jne LBB10_25, $-75(%rip) + LONG $0xfffface9; BYTE $0xff // jmp LBB10_24, $-84(%rip) -LBB14_23: - WORD $0x8941; BYTE $0xda // movl %ebx, %r10d - WORD $0x8945; BYTE $0xe6 // movl %r12d, %r14d - LONG $0x04b60f42; BYTE $0x2f // movzbl (%rdi,%r13), %eax - WORD $0x588d; BYTE $0xd0 // leal $-48(%rax), %ebx - WORD $0xfb80; BYTE $0x09 // cmpb $9, %bl - LONG $0xffc9870f; WORD $0xffff // ja LBB14_33, $-55(%rip) - WORD $0x303c // cmpb $48, %al - LONG $0x0021850f; WORD $0x0000 // jne LBB14_29, $33(%rip) - WORD $0x8545; BYTE $0xdb // testl %r11d, %r11d - LONG $0x0043840f; WORD $0x0000 // je LBB14_26, $67(%rip) - WORD $0x6349; BYTE $0xd8 // movslq %r8d, %rbx - WORD $0x3948; BYTE $0xcb // cmpq %rcx, %rbx - LONG $0x0018820f; WORD $0x0000 // jb LBB14_32, $24(%rip) - LONG $0x000019e9; BYTE $0x00 // jmp LBB14_28, $25(%rip) - LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 +LBB10_31: + WORD $0xc083; BYTE $0x02 // addl $2, %eax + LONG $0xffffb841; WORD $0xffff // movl $-1, %r8d -LBB14_29: - WORD $0x6349; BYTE $0xdb // movslq %r11d, %rbx - WORD $0x3948; BYTE $0xcb // cmpq %rcx, %rbx - LONG $0x0014830f; WORD $0x0000 // jae LBB14_30, $20(%rip) +LBB10_32: + WORD $0xc289 // movl %eax, %edx + WORD $0x6348; BYTE $0xd2 // movslq %edx, %rdx + WORD $0x3145; BYTE $0xc9 // xorl %r9d, %r9d + WORD $0x3948; BYTE $0xf2 // cmpq %rsi, %rdx + LONG $0x00178c0f; WORD $0x0000 // jl LBB10_34, $23(%rip) + LONG $0x00004de9; BYTE $0x00 // jmp LBB10_38, $77(%rip) -LBB14_32: - WORD $0x0488; BYTE $0x1a // movb %al, (%rdx,%rbx) - WORD $0xff41; BYTE $0xc0 // incl %r8d +LBB10_33: + WORD $0xff48; BYTE $0xc2 // incq %rdx + WORD $0x6348; BYTE $0xd2 // movslq %edx, %rdx + WORD $0x3145; BYTE $0xc9 // xorl %r9d, %r9d + WORD $0x3948; BYTE $0xf2 // cmpq %rsi, %rdx + LONG $0x003b8d0f; WORD $0x0000 // jge LBB10_38, $59(%rip) -LBB14_28: - WORD $0x8945; BYTE $0xf4 // movl %r14d, %r12d - WORD $0x8945; BYTE $0xc3 // movl %r8d, %r11d - WORD $0x8944; BYTE $0xd3 // movl %r10d, %ebx - LONG $0xffff90e9; BYTE $0xff // jmp LBB14_34, $-112(%rip) +LBB10_34: + WORD $0x3145; BYTE $0xc9 // xorl %r9d, %r9d + LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 -LBB14_30: - LONG $0x0001b941; WORD $0x0000 // movl $1, %r9d - LONG $0x000006e9; BYTE $0x00 // jmp LBB14_31, $6(%rip) - -LBB14_26: - WORD $0xff41; BYTE $0xce // decl %r14d - WORD $0x3145; BYTE $0xdb // xorl %r11d, %r11d - -LBB14_31: - WORD $0x8945; BYTE $0xf4 // movl %r14d, %r12d - WORD $0x8944; BYTE $0xd3 // movl %r10d, %ebx - LONG $0xffff74e9; BYTE $0xff // jmp LBB14_34, $-140(%rip) - -LBB14_35: - WORD $0x8945; BYTE $0xe6 // movl %r12d, %r14d - WORD $0x8949; BYTE $0xf5 // movq %rsi, %r13 - WORD $0x8941; BYTE $0xda // movl %ebx, %r10d - -LBB14_36: - LONG $0xc4758944 // movl %r14d, $-60(%rbp) - LONG $0xcc4d8944 // movl %r9d, $-52(%rbp) - LONG $0xc0458944 // movl %r8d, $-64(%rbp) - WORD $0x8545; BYTE $0xd2 // testl %r10d, %r10d - LONG $0x0012840f; WORD $0x0000 // je LBB14_37, $18(%rip) - WORD $0x8945; BYTE $0xf0 // movl %r14d, %r8d - LONG $0x01c7f641 // testb $1, %r15b - LONG $0x0013850f; WORD $0x0000 // jne LBB14_40, $19(%rip) - LONG $0x0000c4e9; BYTE $0x00 // jmp LBB14_55, $196(%rip) +LBB10_35: + LONG $0x0ff98141; WORD $0x0027; BYTE $0x00 // cmpl $9999, %r9d + LONG $0x00248f0f; WORD $0x0000 // jg LBB10_38, $36(%rip) + LONG $0x170cb60f // movzbl (%rdi,%rdx), %ecx + WORD $0x418d; BYTE $0xd0 // leal $-48(%rcx), %eax + WORD $0x093c // cmpb $9, %al + LONG $0x0015870f; WORD $0x0000 // ja LBB10_38, $21(%rip) + LONG $0x89048d43 // leal (%r9,%r9,4), %eax + LONG $0x414c8d44; BYTE $0xd0 // leal $-48(%rcx,%rax,2), %r9d + WORD $0xff48; BYTE $0xc2 // incq %rdx + WORD $0x3948; BYTE $0xd6 // cmpq %rdx, %rsi + LONG $0xffcf850f; WORD $0xffff // jne LBB10_35, $-49(%rip) + +LBB10_38: + LONG $0xc8af0f45 // imull %r8d, %r9d + LONG $0xf44d0144 // addl %r9d, $-12(%rbp) + +LBB10_39: + LONG $0xe07d8d48 // leaq $-32(%rbp), %rdi + LONG $0xd8758d48 // leaq $-40(%rbp), %rsi + LONG $0xfff9eae8; BYTE $0xff // callq _decimal_to_f64, $-1558(%rip) + LONG $0x45100ff2; BYTE $0xd8 // movsd $-40(%rbp), %xmm0 + LONG $0x30c48348 // addq $48, %rsp + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 -LBB14_37: - LONG $0xc4458944 // movl %r8d, $-60(%rbp) - LONG $0x01c7f641 // testb $1, %r15b - LONG $0x00b6840f; WORD $0x0000 // je LBB14_55, $182(%rip) - -LBB14_40: - WORD $0x8944; BYTE $0xe8 // movl %r13d, %eax - LONG $0x070cb60f // movzbl (%rdi,%rax), %ecx - WORD $0xc983; BYTE $0x20 // orl $32, %ecx - WORD $0xf983; BYTE $0x65 // cmpl $101, %ecx - LONG $0x00a3850f; WORD $0x0000 // jne LBB14_55, $163(%rip) - LONG $0x0754b60f; BYTE $0x01 // movzbl $1(%rdi,%rax), %edx - WORD $0xfa83; BYTE $0x2d // cmpl $45, %edx - LONG $0x0017840f; WORD $0x0000 // je LBB14_45, $23(%rip) - LONG $0x000001b9; BYTE $0x00 // movl $1, %ecx - WORD $0xfa83; BYTE $0x2b // cmpl $43, %edx - LONG $0x0028850f; WORD $0x0000 // jne LBB14_43, $40(%rip) - LONG $0x02c58341 // addl $2, %r13d - LONG $0x000009e9; BYTE $0x00 // jmp LBB14_46, $9(%rip) +_value: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5741 // pushq %r15 + WORD $0x5641 // pushq %r14 + WORD $0x5541 // pushq %r13 + WORD $0x5441 // pushq %r12 + BYTE $0x53 // pushq %rbx + LONG $0x28ec8348 // subq $40, %rsp + WORD $0x8949; BYTE $0xce // movq %rcx, %r14 + WORD $0x8949; BYTE $0xd4 // movq %rdx, %r12 + WORD $0x8949; BYTE $0xf7 // movq %rsi, %r15 + WORD $0x8949; BYTE $0xfd // movq %rdi, %r13 + LONG $0xd0558948 // movq %rdx, $-48(%rbp) + LONG $0xb07d8948 // movq %rdi, $-80(%rbp) + LONG $0xb8758948 // movq %rsi, $-72(%rbp) + WORD $0x8948; BYTE $0xd0 // movq %rdx, %rax + WORD $0x2948; BYTE $0xf0 // subq %rsi, %rax + LONG $0x002b830f; WORD $0x0000 // jae LBB11_5, $43(%rip) + LONG $0x254c8a43; BYTE $0x00 // movb (%r13,%r12), %cl + WORD $0xf980; BYTE $0x0d // cmpb $13, %cl + LONG $0x001d840f; WORD $0x0000 // je LBB11_5, $29(%rip) + WORD $0xf980; BYTE $0x20 // cmpb $32, %cl + LONG $0x0014840f; WORD $0x0000 // je LBB11_5, $20(%rip) + WORD $0x518d; BYTE $0xf7 // leal $-9(%rcx), %edx + WORD $0xfa80; BYTE $0x01 // cmpb $1, %dl + LONG $0x0008860f; WORD $0x0000 // jbe LBB11_5, $8(%rip) + WORD $0x894c; BYTE $0xe3 // movq %r12, %rbx + LONG $0x000132e9; BYTE $0x00 // jmp LBB11_28, $306(%rip) + +LBB11_5: + LONG $0x245c8d49; BYTE $0x01 // leaq $1(%r12), %rbx + WORD $0x394c; BYTE $0xfb // cmpq %r15, %rbx + LONG $0x0023830f; WORD $0x0000 // jae LBB11_9, $35(%rip) + LONG $0x1d4c8a41; BYTE $0x00 // movb (%r13,%rbx), %cl + WORD $0xf980; BYTE $0x0d // cmpb $13, %cl + LONG $0x0015840f; WORD $0x0000 // je LBB11_9, $21(%rip) + WORD $0xf980; BYTE $0x20 // cmpb $32, %cl + LONG $0x000c840f; WORD $0x0000 // je LBB11_9, $12(%rip) + WORD $0x518d; BYTE $0xf7 // leal $-9(%rcx), %edx + WORD $0xfa80; BYTE $0x01 // cmpb $1, %dl + LONG $0x0101870f; WORD $0x0000 // ja LBB11_28, $257(%rip) + +LBB11_9: + LONG $0x245c8d49; BYTE $0x02 // leaq $2(%r12), %rbx + WORD $0x394c; BYTE $0xfb // cmpq %r15, %rbx + LONG $0x0023830f; WORD $0x0000 // jae LBB11_13, $35(%rip) + LONG $0x1d4c8a41; BYTE $0x00 // movb (%r13,%rbx), %cl + WORD $0xf980; BYTE $0x0d // cmpb $13, %cl + LONG $0x0015840f; WORD $0x0000 // je LBB11_13, $21(%rip) + WORD $0xf980; BYTE $0x20 // cmpb $32, %cl + LONG $0x000c840f; WORD $0x0000 // je LBB11_13, $12(%rip) + WORD $0x518d; BYTE $0xf7 // leal $-9(%rcx), %edx + WORD $0xfa80; BYTE $0x01 // cmpb $1, %dl + LONG $0x00d0870f; WORD $0x0000 // ja LBB11_28, $208(%rip) -LBB14_45: - LONG $0x02c58341 // addl $2, %r13d - LONG $0xffffffb9; BYTE $0xff // movl $-1, %ecx +LBB11_13: + LONG $0x245c8d49; BYTE $0x03 // leaq $3(%r12), %rbx + WORD $0x394c; BYTE $0xfb // cmpq %r15, %rbx + LONG $0x0023830f; WORD $0x0000 // jae LBB11_17, $35(%rip) + LONG $0x1d4c8a41; BYTE $0x00 // movb (%r13,%rbx), %cl + WORD $0xf980; BYTE $0x0d // cmpb $13, %cl + LONG $0x0015840f; WORD $0x0000 // je LBB11_17, $21(%rip) + WORD $0xf980; BYTE $0x20 // cmpb $32, %cl + LONG $0x000c840f; WORD $0x0000 // je LBB11_17, $12(%rip) + WORD $0x518d; BYTE $0xf7 // leal $-9(%rcx), %edx + WORD $0xfa80; BYTE $0x01 // cmpb $1, %dl + LONG $0x009f870f; WORD $0x0000 // ja LBB11_28, $159(%rip) -LBB14_46: - WORD $0x8944; BYTE $0xe8 // movl %r13d, %eax - WORD $0x6348; BYTE $0xd0 // movslq %eax, %rdx - WORD $0xc031 // xorl %eax, %eax - WORD $0x3948; BYTE $0xf2 // cmpq %rsi, %rdx - LONG $0x00168c0f; WORD $0x0000 // jl LBB14_48, $22(%rip) - LONG $0x000055e9; BYTE $0x00 // jmp LBB14_53, $85(%rip) +LBB11_17: + LONG $0x244c8d49; BYTE $0x04 // leaq $4(%r12), %rcx + WORD $0x394c; BYTE $0xf9 // cmpq %r15, %rcx + LONG $0x0057830f; WORD $0x0000 // jae LBB11_23, $87(%rip) + WORD $0x3949; BYTE $0xcf // cmpq %rcx, %r15 + LONG $0x005a840f; WORD $0x0000 // je LBB11_24, $90(%rip) + LONG $0x3d4c8d4b; BYTE $0x00 // leaq (%r13,%r15), %rcx + LONG $0x04c08348 // addq $4, %rax + LONG $0x2c5c8d4b; BYTE $0x05 // leaq $5(%r12,%r13), %rbx + QUAD $0x000100002600ba48; WORD $0x0000 // movabsq $4294977024, %rdx + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 -LBB14_43: +LBB11_20: + LONG $0xff73be0f // movsbl $-1(%rbx), %esi + WORD $0xfe83; BYTE $0x20 // cmpl $32, %esi + LONG $0x003e870f; WORD $0x0000 // ja LBB11_26, $62(%rip) + LONG $0xf2a30f48 // btq %rsi, %rdx + LONG $0x0034830f; WORD $0x0000 // jae LBB11_26, $52(%rip) + WORD $0xff48; BYTE $0xc3 // incq %rbx WORD $0xff48; BYTE $0xc0 // incq %rax - WORD $0x6348; BYTE $0xd0 // movslq %eax, %rdx - WORD $0xc031 // xorl %eax, %eax - WORD $0x3948; BYTE $0xf2 // cmpq %rsi, %rdx - LONG $0x00448d0f; WORD $0x0000 // jge LBB14_53, $68(%rip) + LONG $0xffdd850f; WORD $0xffff // jne LBB11_20, $-35(%rip) + LONG $0x00000fe9; BYTE $0x00 // jmp LBB11_25, $15(%rip) -LBB14_48: - WORD $0xc031 // xorl %eax, %eax - QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90 +LBB11_23: + LONG $0xd04d8948 // movq %rcx, $-48(%rbp) + WORD $0x8949; BYTE $0xcc // movq %rcx, %r12 + LONG $0x000079e9; BYTE $0x00 // jmp LBB11_32, $121(%rip) -LBB14_49: - LONG $0x171cbe0f // movsbl (%rdi,%rdx), %ebx - WORD $0xfb83; BYTE $0x30 // cmpl $48, %ebx - LONG $0x00298c0f; WORD $0x0000 // jl LBB14_53, $41(%rip) - WORD $0xfb80; BYTE $0x39 // cmpb $57, %bl - LONG $0x0020870f; WORD $0x0000 // ja LBB14_53, $32(%rip) - LONG $0x00270f3d; BYTE $0x00 // cmpl $9999, %eax - LONG $0x00158f0f; WORD $0x0000 // jg LBB14_53, $21(%rip) - WORD $0x048d; BYTE $0x80 // leal (%rax,%rax,4), %eax - WORD $0x048d; BYTE $0x43 // leal (%rbx,%rax,2), %eax - WORD $0xc083; BYTE $0xd0 // addl $-48, %eax - WORD $0xff48; BYTE $0xc2 // incq %rdx - WORD $0x3948; BYTE $0xd6 // cmpq %rdx, %rsi - LONG $0xffca850f; WORD $0xffff // jne LBB14_49, $-54(%rip) +LBB11_24: + WORD $0x014c; BYTE $0xe9 // addq %r13, %rcx -LBB14_53: - WORD $0xaf0f; BYTE $0xc1 // imull %ecx, %eax - WORD $0x0141; BYTE $0xc0 // addl %eax, %r8d +LBB11_25: + WORD $0x294c; BYTE $0xe9 // subq %r13, %rcx + WORD $0x8948; BYTE $0xcb // movq %rcx, %rbx + WORD $0x394c; BYTE $0xfb // cmpq %r15, %rbx + LONG $0x0017820f; WORD $0x0000 // jb LBB11_27, $23(%rip) + LONG $0x000062e9; BYTE $0x00 // jmp LBB11_32, $98(%rip) -LBB14_54: - LONG $0xc4458944 // movl %r8d, $-60(%rbp) +LBB11_26: + WORD $0x894c; BYTE $0xe8 // movq %r13, %rax + WORD $0xf748; BYTE $0xd0 // notq %rax + WORD $0x0148; BYTE $0xc3 // addq %rax, %rbx + WORD $0x394c; BYTE $0xfb // cmpq %r15, %rbx + LONG $0x0050830f; WORD $0x0000 // jae LBB11_32, $80(%rip) -LBB14_55: - LONG $0xb07d8d48 // leaq $-80(%rbp), %rdi - LONG $0xd0758d48 // leaq $-48(%rbp), %rsi - LONG $0xfff893e8; BYTE $0xff // callq _decimal_to_f64, $-1901(%rip) - LONG $0x45100ff2; BYTE $0xd0 // movsd $-48(%rbp), %xmm0 - LONG $0x28c48348 // addq $40, %rsp - BYTE $0x5b // popq %rbx - WORD $0x5c41 // popq %r12 - WORD $0x5d41 // popq %r13 - WORD $0x5e41 // popq %r14 - WORD $0x5f41 // popq %r15 - BYTE $0x5d // popq %rbp - BYTE $0xc3 // retq - QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 +LBB11_27: + LONG $0x1d4c8a41; BYTE $0x00 // movb (%r13,%rbx), %cl -_value: - BYTE $0x55 // pushq %rbp - WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp - WORD $0x5741 // pushq %r15 - WORD $0x5641 // pushq %r14 - WORD $0x5541 // pushq %r13 - WORD $0x5441 // pushq %r12 - BYTE $0x53 // pushq %rbx - LONG $0x28ec8348 // subq $40, %rsp - WORD $0x894d; BYTE $0xc7 // movq %r8, %r15 - WORD $0x8949; BYTE $0xce // movq %rcx, %r14 - WORD $0x8948; BYTE $0xf3 // movq %rsi, %rbx - WORD $0x8949; BYTE $0xfc // movq %rdi, %r12 - LONG $0xd0558948 // movq %rdx, $-48(%rbp) - LONG $0xb07d8948 // movq %rdi, $-80(%rbp) - LONG $0xb8758948 // movq %rsi, $-72(%rbp) - LONG $0xd0558d48 // leaq $-48(%rbp), %rdx - LONG $0x0005eee8; BYTE $0x00 // callq _advance_ns, $1518(%rip) - WORD $0xbe0f; BYTE $0xc0 // movsbl %al, %eax +LBB11_28: + LONG $0x01638d4c // leaq $1(%rbx), %r12 + LONG $0xd065894c // movq %r12, $-48(%rbp) + WORD $0xbe0f; BYTE $0xc1 // movsbl %cl, %eax WORD $0xf883; BYTE $0x7d // cmpl $125, %eax - LONG $0x00bc870f; WORD $0x0000 // ja LBB15_11, $188(%rip) - LONG $0x9f0d8d48; WORD $0x0003; BYTE $0x00 // leaq $927(%rip), %rcx /* LJTI15_0(%rip) */ - LONG $0x81046348 // movslq (%rcx,%rax,4), %rax - WORD $0x0148; BYTE $0xc8 // addq %rcx, %rax + LONG $0x00c4870f; WORD $0x0000 // ja LBB11_41, $196(%rip) + LONG $0x83158d48; WORD $0x0003; BYTE $0x00 // leaq $899(%rip), %rdx /* LJTI11_0(%rip) */ + LONG $0x82046348 // movslq (%rdx,%rax,4), %rax + WORD $0x0148; BYTE $0xd0 // addq %rdx, %rax JMP AX -LBB15_2: - LONG $0xc875894c // movq %r14, $-56(%rbp) - LONG $0xd0758b4c // movq $-48(%rbp), %r14 - LONG $0xff6e8d4d // leaq $-1(%r14), %r13 - LONG $0xd06d894c // movq %r13, $-48(%rbp) - LONG $0x02c7f641 // testb $2, %r15b - LONG $0x001a850f; WORD $0x0000 // jne LBB15_4, $26(%rip) +LBB11_30: + LONG $0xd05d8948 // movq %rbx, $-48(%rbp) + LONG $0x02c0f641 // testb $2, %r8b + LONG $0x0035850f; WORD $0x0000 // jne LBB11_35, $53(%rip) LONG $0xb07d8d48 // leaq $-80(%rbp), %rdi LONG $0xd0758d48 // leaq $-48(%rbp), %rsi - LONG $0xc8558b48 // movq $-56(%rbp), %rdx - LONG $0x000e07e8; BYTE $0x00 // callq _vnumber, $3591(%rip) - LONG $0xd07d8b4c // movq $-48(%rbp), %r15 - LONG $0x00034de9; BYTE $0x00 // jmp LBB15_58, $845(%rip) + WORD $0x894c; BYTE $0xf2 // movq %r14, %rdx + LONG $0x000bace8; BYTE $0x00 // callq _vnumber, $2988(%rip) + LONG $0xd05d8b48 // movq $-48(%rbp), %rbx + LONG $0x00000ae9; BYTE $0x00 // jmp LBB11_34, $10(%rip) + +LBB11_32: + LONG $0x0106c749; WORD $0x0000; BYTE $0x00 // movq $1, (%r14) + +LBB11_33: + WORD $0x894c; BYTE $0xe3 // movq %r12, %rbx + +LBB11_34: + WORD $0x8948; BYTE $0xd8 // movq %rbx, %rax + LONG $0x28c48348 // addq $40, %rsp + BYTE $0x5b // popq %rbx + WORD $0x5c41 // popq %r12 + WORD $0x5d41 // popq %r13 + WORD $0x5e41 // popq %r14 + WORD $0x5f41 // popq %r15 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq -LBB15_4: +LBB11_35: + LONG $0xc875894c // movq %r14, $-56(%rbp) + LONG $0x1d748d4d; BYTE $0x00 // leaq (%r13,%rbx), %r14 WORD $0xc031 // xorl %eax, %eax - LONG $0x2c3c8043; BYTE $0x2d // cmpb $45, (%r12,%r13) - LONG $0x2c3c8d4f // leaq (%r12,%r13), %r15 + WORD $0xf980; BYTE $0x2d // cmpb $45, %cl WORD $0x940f; BYTE $0xc0 // sete %al - WORD $0x0149; BYTE $0xc7 // addq %rax, %r15 - WORD $0x2948; BYTE $0xc3 // subq %rax, %rbx - LONG $0x030c840f; WORD $0x0000 // je LBB15_53, $780(%rip) - WORD $0x3949; BYTE $0xdd // cmpq %rbx, %r13 - LONG $0x000e830f; WORD $0x0000 // jae LBB15_7, $14(%rip) - LONG $0x07b60f41 // movzbl (%r15), %eax - WORD $0xc604 // addb $-58, %al - WORD $0xf63c // cmpb $-10, %al - LONG $0x0307820f; WORD $0x0000 // jb LBB15_55, $775(%rip) + WORD $0x0149; BYTE $0xc6 // addq %rax, %r14 + WORD $0x2949; BYTE $0xc7 // subq %rax, %r15 + LONG $0x02e2840f; WORD $0x0000 // je LBB11_85, $738(%rip) + WORD $0x394c; BYTE $0xfb // cmpq %r15, %rbx + LONG $0x000d830f; WORD $0x0000 // jae LBB11_38, $13(%rip) + WORD $0x8a41; BYTE $0x06 // movb (%r14), %al + WORD $0xd004 // addb $-48, %al + WORD $0x0a3c // cmpb $10, %al + LONG $0x02e5830f; WORD $0x0000 // jae LBB11_87, $741(%rip) -LBB15_7: - WORD $0x894c; BYTE $0xff // movq %r15, %rdi - WORD $0x8948; BYTE $0xde // movq %rbx, %rsi - LONG $0x001f42e8; BYTE $0x00 // callq _do_skip_number, $8002(%rip) +LBB11_38: + WORD $0x894c; BYTE $0xf7 // movq %r14, %rdi + WORD $0x894c; BYTE $0xfe // movq %r15, %rsi + LONG $0x001f59e8; BYTE $0x00 // callq _do_skip_number, $8025(%rip) WORD $0x8548; BYTE $0xc0 // testq %rax, %rax - LONG $0x02ed880f; WORD $0x0000 // js LBB15_54, $749(%rip) - WORD $0x0149; BYTE $0xc7 // addq %rax, %r15 - WORD $0x294d; BYTE $0xe7 // subq %r12, %r15 - WORD $0x854d; BYTE $0xf6 // testq %r14, %r14 - LONG $0x02f28e0f; WORD $0x0000 // jle LBB15_57, $754(%rip) + LONG $0x02cb880f; WORD $0x0000 // js LBB11_86, $715(%rip) + WORD $0x0149; BYTE $0xc6 // addq %rax, %r14 + WORD $0x294d; BYTE $0xee // subq %r13, %r14 + LONG $0xd075894c // movq %r14, $-48(%rbp) + WORD $0x854d; BYTE $0xe4 // testq %r12, %r12 + LONG $0x02cc8e0f; WORD $0x0000 // jle LBB11_88, $716(%rip) LONG $0xc8458b48 // movq $-56(%rbp), %rax LONG $0x0800c748; WORD $0x0000; BYTE $0x00 // movq $8, (%rax) - LONG $0x1868894c // movq %r13, $24(%rax) - LONG $0x0002e5e9; BYTE $0x00 // jmp LBB15_58, $741(%rip) - -LBB15_10: - LONG $0x0106c749; WORD $0x0000; BYTE $0x00 // movq $1, (%r14) - LONG $0xd07d8b4c // movq $-48(%rbp), %r15 - LONG $0x0002d5e9; BYTE $0x00 // jmp LBB15_58, $725(%rip) + LONG $0x18588948 // movq %rbx, $24(%rax) + WORD $0x894c; BYTE $0xf3 // movq %r14, %rbx + LONG $0xffff7de9; BYTE $0xff // jmp LBB11_34, $-131(%rip) -LBB15_11: +LBB11_41: LONG $0xfe06c749; WORD $0xffff; BYTE $0xff // movq $-2, (%r14) - LONG $0xd07d8b4c // movq $-48(%rbp), %r15 - WORD $0xff49; BYTE $0xcf // decq %r15 - LONG $0x0002c2e9; BYTE $0x00 // jmp LBB15_58, $706(%rip) + LONG $0xffff71e9; BYTE $0xff // jmp LBB11_34, $-143(%rip) -LBB15_12: +LBB11_42: QUAD $0xffffffffc045c748 // movq $-1, $-64(%rbp) - LONG $0xd0658b4c // movq $-48(%rbp), %r12 LONG $0xb07d8d48 // leaq $-80(%rbp), %rdi LONG $0xc0558d48 // leaq $-64(%rbp), %rdx WORD $0x894c; BYTE $0xe6 // movq %r12, %rsi - WORD $0x894c; BYTE $0xf9 // movq %r15, %rcx - LONG $0x000814e8; BYTE $0x00 // callq _advance_string, $2068(%rip) - WORD $0x8949; BYTE $0xc7 // movq %rax, %r15 + WORD $0x894c; BYTE $0xc1 // movq %r8, %rcx + LONG $0x00054fe8; BYTE $0x00 // callq _advance_string, $1359(%rip) + WORD $0x8948; BYTE $0xc3 // movq %rax, %rbx WORD $0x8548; BYTE $0xc0 // testq %rax, %rax - LONG $0x0174880f; WORD $0x0000 // js LBB15_32, $372(%rip) - LONG $0xd07d894c // movq %r15, $-48(%rbp) + LONG $0x0150880f; WORD $0x0000 // js LBB11_61, $336(%rip) + LONG $0xd05d8948 // movq %rbx, $-48(%rbp) LONG $0x1066894d // movq %r12, $16(%r14) - LONG $0x0706c749; WORD $0x0000; BYTE $0x00 // movq $7, (%r14) LONG $0xc0458b48 // movq $-64(%rbp), %rax - WORD $0x394c; BYTE $0xf8 // cmpq %r15, %rax + WORD $0x3948; BYTE $0xd8 // cmpq %rbx, %rax LONG $0xffc1c748; WORD $0xffff; BYTE $0xff // movq $-1, %rcx LONG $0xc84c0f48 // cmovlq %rax, %rcx LONG $0x184e8949 // movq %rcx, $24(%r14) - LONG $0x00026de9; BYTE $0x00 // jmp LBB15_58, $621(%rip) + LONG $0x000007b8; BYTE $0x00 // movl $7, %eax + WORD $0x8949; BYTE $0x06 // movq %rax, (%r14) + LONG $0xffff1fe9; BYTE $0xff // jmp LBB11_34, $-225(%rip) -LBB15_14: - WORD $0xc031 // xorl %eax, %eax - LONG $0x00c7f741; WORD $0x0000; BYTE $0x80 // testl $-2147483648, %r15d - LONG $0xfec1c748; WORD $0xffff; BYTE $0xff // movq $-2, %rcx - LONG $0x00000bba; BYTE $0x00 // movl $11, %edx - LONG $0x00011ae9; BYTE $0x00 // jmp LBB15_31, $282(%rip) +LBB11_44: + WORD $0x8545; BYTE $0xc0 // testl %r8d, %r8d + LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq $-2, %rax + LONG $0x00000bb9; BYTE $0x00 // movl $11, %ecx + LONG $0x0000f8e9; BYTE $0x00 // jmp LBB11_60, $248(%rip) -LBB15_15: - WORD $0xc031 // xorl %eax, %eax - LONG $0x00c7f741; WORD $0x0000; BYTE $0x80 // testl $-2147483648, %r15d - LONG $0xfec1c748; WORD $0xffff; BYTE $0xff // movq $-2, %rcx - LONG $0x00000aba; BYTE $0x00 // movl $10, %edx - LONG $0x000100e9; BYTE $0x00 // jmp LBB15_31, $256(%rip) +LBB11_45: + WORD $0x8545; BYTE $0xc0 // testl %r8d, %r8d + LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq $-2, %rax + LONG $0x00000ab9; BYTE $0x00 // movl $10, %ecx + LONG $0x0000e4e9; BYTE $0x00 // jmp LBB11_60, $228(%rip) -LBB15_16: +LBB11_46: LONG $0x0506c749; WORD $0x0000; BYTE $0x00 // movq $5, (%r14) - LONG $0xd07d8b4c // movq $-48(%rbp), %r15 - LONG $0x000229e9; BYTE $0x00 // jmp LBB15_58, $553(%rip) + LONG $0xfffee8e9; BYTE $0xff // jmp LBB11_33, $-280(%rip) -LBB15_17: - WORD $0xc031 // xorl %eax, %eax - LONG $0x00c7f741; WORD $0x0000; BYTE $0x80 // testl $-2147483648, %r15d - LONG $0xfec1c748; WORD $0xffff; BYTE $0xff // movq $-2, %rcx - LONG $0x00000cba; BYTE $0x00 // movl $12, %edx - LONG $0x0000d6e9; BYTE $0x00 // jmp LBB15_31, $214(%rip) +LBB11_47: + WORD $0x8545; BYTE $0xc0 // testl %r8d, %r8d + LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq $-2, %rax + LONG $0x00000cb9; BYTE $0x00 // movl $12, %ecx + LONG $0x0000c4e9; BYTE $0x00 // jmp LBB11_60, $196(%rip) -LBB15_18: - LONG $0xd07d8b4c // movq $-48(%rbp), %r15 - LONG $0xfc4b8d48 // leaq $-4(%rbx), %rcx - LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax - WORD $0x3949; BYTE $0xcf // cmpq %rcx, %r15 - LONG $0x008a870f; WORD $0x0000 // ja LBB15_25, $138(%rip) - LONG $0x3c0c8b43 // movl (%r12,%r15), %ecx - LONG $0x6c61f981; WORD $0x6573 // cmpl $1702063201, %ecx - LONG $0x00d3850f; WORD $0x0000 // jne LBB15_33, $211(%rip) - LONG $0x04c78349 // addq $4, %r15 - LONG $0x000004b8; BYTE $0x00 // movl $4, %eax - LONG $0x000069e9; BYTE $0x00 // jmp LBB15_24, $105(%rip) - -LBB15_21: - LONG $0xd07d8b4c // movq $-48(%rbp), %r15 - LONG $0xfd4b8d48 // leaq $-3(%rbx), %rcx - LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax - WORD $0x3949; BYTE $0xcf // cmpq %rcx, %r15 - LONG $0x0054870f; WORD $0x0000 // ja LBB15_25, $84(%rip) - LONG $0x3c4c8b43; BYTE $0xff // movl $-1(%r12,%r15), %ecx - LONG $0x756ef981; WORD $0x6c6c // cmpl $1819047278, %ecx - LONG $0x00db850f; WORD $0x0000 // jne LBB15_37, $219(%rip) - LONG $0x03c78349 // addq $3, %r15 - LONG $0x000002b8; BYTE $0x00 // movl $2, %eax - LONG $0x000032e9; BYTE $0x00 // jmp LBB15_24, $50(%rip) +LBB11_48: + LONG $0xfc478d49 // leaq $-4(%r15), %rax + WORD $0x3948; BYTE $0xc3 // cmpq %rax, %rbx + LONG $0x008c830f; WORD $0x0000 // jae LBB11_57, $140(%rip) + LONG $0x254c8b43; BYTE $0x00 // movl (%r13,%r12), %ecx + LONG $0x6c61f981; WORD $0x6573 // cmpl $1702063201, %ecx + LONG $0x00ce850f; WORD $0x0000 // jne LBB11_62, $206(%rip) + LONG $0x05c38348 // addq $5, %rbx + LONG $0xd05d8948 // movq %rbx, $-48(%rbp) + LONG $0x000004b8; BYTE $0x00 // movl $4, %eax + WORD $0x8949; BYTE $0xdf // movq %rbx, %r15 + LONG $0x0001aae9; BYTE $0x00 // jmp LBB11_84, $426(%rip) -LBB15_26: - LONG $0xd07d8b4c // movq $-48(%rbp), %r15 - LONG $0xfd4b8d48 // leaq $-3(%rbx), %rcx - LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax - WORD $0x3949; BYTE $0xcf // cmpq %rcx, %r15 - LONG $0x001d870f; WORD $0x0000 // ja LBB15_25, $29(%rip) - LONG $0x3c4c8b43; BYTE $0xff // movl $-1(%r12,%r15), %ecx - LONG $0x7274f981; WORD $0x6575 // cmpl $1702195828, %ecx - LONG $0x00e2850f; WORD $0x0000 // jne LBB15_41, $226(%rip) - LONG $0x03c78349 // addq $3, %r15 - LONG $0x000003b8; BYTE $0x00 // movl $3, %eax +LBB11_51: + LONG $0xfd478d49 // leaq $-3(%r15), %rax + WORD $0x3948; BYTE $0xc3 // cmpq %rax, %rbx + LONG $0x0059830f; WORD $0x0000 // jae LBB11_57, $89(%rip) + LONG $0x1d4c8b41; BYTE $0x00 // movl (%r13,%rbx), %ecx + LONG $0x756ef981; WORD $0x6c6c // cmpl $1819047278, %ecx + LONG $0x00da850f; WORD $0x0000 // jne LBB11_66, $218(%rip) + LONG $0x04c38348 // addq $4, %rbx + LONG $0xd05d8948 // movq %rbx, $-48(%rbp) + LONG $0x000002b8; BYTE $0x00 // movl $2, %eax + WORD $0x8949; BYTE $0xdf // movq %rbx, %r15 + LONG $0x000177e9; BYTE $0x00 // jmp LBB11_84, $375(%rip) -LBB15_24: - WORD $0x894c; BYTE $0xfb // movq %r15, %rbx +LBB11_54: + LONG $0xfd478d49 // leaq $-3(%r15), %rax + WORD $0x3948; BYTE $0xc3 // cmpq %rax, %rbx + LONG $0x0026830f; WORD $0x0000 // jae LBB11_57, $38(%rip) + LONG $0x1d4c8b41; BYTE $0x00 // movl (%r13,%rbx), %ecx + LONG $0x7274f981; WORD $0x6575 // cmpl $1702195828, %ecx + LONG $0x00ea850f; WORD $0x0000 // jne LBB11_70, $234(%rip) + LONG $0x04c38348 // addq $4, %rbx + LONG $0xd05d8948 // movq %rbx, $-48(%rbp) + LONG $0x000003b8; BYTE $0x00 // movl $3, %eax + WORD $0x8949; BYTE $0xdf // movq %rbx, %r15 + LONG $0x000144e9; BYTE $0x00 // jmp LBB11_84, $324(%rip) -LBB15_25: - LONG $0xd05d8948 // movq %rbx, $-48(%rbp) - WORD $0x8949; BYTE $0xdf // movq %rbx, %r15 - WORD $0x8949; BYTE $0x06 // movq %rax, (%r14) - LONG $0x00015ee9; BYTE $0x00 // jmp LBB15_58, $350(%rip) +LBB11_57: + LONG $0xd07d894c // movq %r15, $-48(%rbp) + LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax + LONG $0x000134e9; BYTE $0x00 // jmp LBB11_84, $308(%rip) -LBB15_29: +LBB11_58: LONG $0x0606c749; WORD $0x0000; BYTE $0x00 // movq $6, (%r14) - LONG $0xd07d8b4c // movq $-48(%rbp), %r15 - LONG $0x00014ee9; BYTE $0x00 // jmp LBB15_58, $334(%rip) + LONG $0xfffe1fe9; BYTE $0xff // jmp LBB11_33, $-481(%rip) -LBB15_30: - WORD $0xc031 // xorl %eax, %eax - LONG $0x00c7f741; WORD $0x0000; BYTE $0x80 // testl $-2147483648, %r15d - LONG $0xfec1c748; WORD $0xffff; BYTE $0xff // movq $-2, %rcx - LONG $0x00000dba; BYTE $0x00 // movl $13, %edx - -LBB15_31: - LONG $0xd1440f48 // cmoveq %rcx, %rdx - WORD $0x940f; BYTE $0xc0 // sete %al - WORD $0x8949; BYTE $0x16 // movq %rdx, (%r14) - LONG $0xd07d8b4c // movq $-48(%rbp), %r15 - WORD $0x2949; BYTE $0xc7 // subq %rax, %r15 - LONG $0x000123e9; BYTE $0x00 // jmp LBB15_58, $291(%rip) - -LBB15_32: - LONG $0xd05d8948 // movq %rbx, $-48(%rbp) - WORD $0x894d; BYTE $0x3e // movq %r15, (%r14) - WORD $0x8949; BYTE $0xdf // movq %rbx, %r15 - LONG $0x000114e9; BYTE $0x00 // jmp LBB15_58, $276(%rip) +LBB11_59: + WORD $0x8545; BYTE $0xc0 // testl %r8d, %r8d + LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq $-2, %rax + LONG $0x00000db9; BYTE $0x00 // movl $13, %ecx + +LBB11_60: + LONG $0xc8490f48 // cmovnsq %rax, %rcx + WORD $0x8949; BYTE $0x0e // movq %rcx, (%r14) + LONG $0x1ff8c141 // sarl $31, %r8d + WORD $0xf741; BYTE $0xd0 // notl %r8d + WORD $0x6349; BYTE $0xc0 // movslq %r8d, %rax + WORD $0x0149; BYTE $0xc4 // addq %rax, %r12 + LONG $0xfffdf7e9; BYTE $0xff // jmp LBB11_33, $-521(%rip) -LBB15_33: +LBB11_61: + LONG $0xd07d894c // movq %r15, $-48(%rbp) + WORD $0x8949; BYTE $0x1e // movq %rbx, (%r14) + WORD $0x894c; BYTE $0xfb // movq %r15, %rbx + LONG $0xfffdebe9; BYTE $0xff // jmp LBB11_34, $-533(%rip) + +LBB11_62: LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq $-2, %rax WORD $0xf980; BYTE $0x61 // cmpb $97, %cl - LONG $0x00d5850f; WORD $0x0000 // jne LBB15_49, $213(%rip) - LONG $0x3c7c8043; WORD $0x6c01 // cmpb $108, $1(%r12,%r15) - LONG $0x00aa850f; WORD $0x0000 // jne LBB15_46, $170(%rip) - LONG $0x3c7c8043; WORD $0x7302 // cmpb $115, $2(%r12,%r15) - LONG $0x00b5850f; WORD $0x0000 // jne LBB15_47, $181(%rip) - LONG $0x044f8d49 // leaq $4(%r15), %rcx - LONG $0x3c7c8043; WORD $0x6503 // cmpb $101, $3(%r12,%r15) - LONG $0x037f8d4d // leaq $3(%r15), %r15 + LONG $0x00bd850f; WORD $0x0000 // jne LBB11_74, $189(%rip) + LONG $0x1d7c8041; WORD $0x6c02 // cmpb $108, $2(%r13,%rbx) + LONG $0x00c1850f; WORD $0x0000 // jne LBB11_81, $193(%rip) + LONG $0x1d7c8041; WORD $0x7303 // cmpb $115, $3(%r13,%rbx) + LONG $0x00be850f; WORD $0x0000 // jne LBB11_79, $190(%rip) + LONG $0x047b8d4c // leaq $4(%rbx), %r15 + LONG $0x054b8d48 // leaq $5(%rbx), %rcx + LONG $0x1d7c8041; WORD $0x6504 // cmpb $101, $4(%r13,%rbx) LONG $0xf9440f4c // cmoveq %rcx, %r15 - LONG $0x0000a2e9; BYTE $0x00 // jmp LBB15_48, $162(%rip) + LONG $0x0000aee9; BYTE $0x00 // jmp LBB11_83, $174(%rip) -LBB15_37: +LBB11_66: + LONG $0xd05d8948 // movq %rbx, $-48(%rbp) LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq $-2, %rax WORD $0xf980; BYTE $0x6e // cmpb $110, %cl - LONG $0x006c850f; WORD $0x0000 // jne LBB15_45, $108(%rip) - LONG $0x3c3c8043; BYTE $0x75 // cmpb $117, (%r12,%r15) - LONG $0x0077850f; WORD $0x0000 // jne LBB15_51, $119(%rip) - LONG $0x3c7c8043; WORD $0x6c01 // cmpb $108, $1(%r12,%r15) - LONG $0x0068850f; WORD $0x0000 // jne LBB15_50, $104(%rip) - LONG $0x034f8d49 // leaq $3(%r15), %rcx - LONG $0x3c7c8043; WORD $0x6c02 // cmpb $108, $2(%r12,%r15) - LONG $0x027f8d4d // leaq $2(%r15), %r15 + LONG $0x0072850f; WORD $0x0000 // jne LBB11_76, $114(%rip) + LONG $0x1d7c8041; WORD $0x7501 // cmpb $117, $1(%r13,%rbx) + LONG $0x0076850f; WORD $0x0000 // jne LBB11_77, $118(%rip) + LONG $0x1d7c8041; WORD $0x6c02 // cmpb $108, $2(%r13,%rbx) + LONG $0x0072850f; WORD $0x0000 // jne LBB11_81, $114(%rip) + LONG $0x037b8d4c // leaq $3(%rbx), %r15 + LONG $0x044b8d48 // leaq $4(%rbx), %rcx + LONG $0x1d7c8041; WORD $0x6c03 // cmpb $108, $3(%r13,%rbx) LONG $0xf9440f4c // cmoveq %rcx, %r15 - LONG $0x000054e9; BYTE $0x00 // jmp LBB15_51, $84(%rip) + LONG $0x00006be9; BYTE $0x00 // jmp LBB11_83, $107(%rip) -LBB15_41: +LBB11_70: + LONG $0xd05d8948 // movq %rbx, $-48(%rbp) LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq $-2, %rax WORD $0xf980; BYTE $0x74 // cmpb $116, %cl - LONG $0x002e850f; WORD $0x0000 // jne LBB15_45, $46(%rip) - LONG $0x3c3c8043; BYTE $0x72 // cmpb $114, (%r12,%r15) - LONG $0x0039850f; WORD $0x0000 // jne LBB15_51, $57(%rip) - LONG $0x3c7c8043; WORD $0x7501 // cmpb $117, $1(%r12,%r15) - LONG $0x002a850f; WORD $0x0000 // jne LBB15_50, $42(%rip) - LONG $0x034f8d49 // leaq $3(%r15), %rcx - LONG $0x3c7c8043; WORD $0x6502 // cmpb $101, $2(%r12,%r15) - LONG $0x027f8d4d // leaq $2(%r15), %r15 + LONG $0x002f850f; WORD $0x0000 // jne LBB11_76, $47(%rip) + LONG $0x1d7c8041; WORD $0x7201 // cmpb $114, $1(%r13,%rbx) + LONG $0x0033850f; WORD $0x0000 // jne LBB11_77, $51(%rip) + LONG $0x1d7c8041; WORD $0x7502 // cmpb $117, $2(%r13,%rbx) + LONG $0x002f850f; WORD $0x0000 // jne LBB11_81, $47(%rip) + LONG $0x037b8d4c // leaq $3(%rbx), %r15 + LONG $0x044b8d48 // leaq $4(%rbx), %rcx + LONG $0x1d7c8041; WORD $0x6503 // cmpb $101, $3(%r13,%rbx) LONG $0xf9440f4c // cmoveq %rcx, %r15 - LONG $0x000016e9; BYTE $0x00 // jmp LBB15_51, $22(%rip) + LONG $0x000028e9; BYTE $0x00 // jmp LBB11_83, $40(%rip) -LBB15_45: - WORD $0xff49; BYTE $0xcf // decq %r15 - WORD $0x8949; BYTE $0x06 // movq %rax, (%r14) - LONG $0x00004ee9; BYTE $0x00 // jmp LBB15_58, $78(%rip) +LBB11_76: + WORD $0x8949; BYTE $0xdf // movq %rbx, %r15 + LONG $0x000024e9; BYTE $0x00 // jmp LBB11_84, $36(%rip) -LBB15_46: - WORD $0xff49; BYTE $0xc7 // incq %r15 - LONG $0x000013e9; BYTE $0x00 // jmp LBB15_48, $19(%rip) +LBB11_74: + WORD $0x894d; BYTE $0xe7 // movq %r12, %r15 + LONG $0x00001ce9; BYTE $0x00 // jmp LBB11_84, $28(%rip) -LBB15_50: - WORD $0xff49; BYTE $0xc7 // incq %r15 +LBB11_77: + WORD $0xff48; BYTE $0xc3 // incq %rbx + LONG $0x00000de9; BYTE $0x00 // jmp LBB11_82, $13(%rip) -LBB15_51: - LONG $0xd07d894c // movq %r15, $-48(%rbp) - WORD $0x8949; BYTE $0x06 // movq %rax, (%r14) - LONG $0x000037e9; BYTE $0x00 // jmp LBB15_58, $55(%rip) +LBB11_81: + LONG $0x02c38348 // addq $2, %rbx + LONG $0x000004e9; BYTE $0x00 // jmp LBB11_82, $4(%rip) + +LBB11_79: + LONG $0x03c38348 // addq $3, %rbx -LBB15_47: - LONG $0x02c78349 // addq $2, %r15 +LBB11_82: + WORD $0x8949; BYTE $0xdf // movq %rbx, %r15 -LBB15_48: +LBB11_83: LONG $0xd07d894c // movq %r15, $-48(%rbp) -LBB15_49: +LBB11_84: WORD $0x8949; BYTE $0x06 // movq %rax, (%r14) - LONG $0x000027e9; BYTE $0x00 // jmp LBB15_58, $39(%rip) + WORD $0x894c; BYTE $0xfb // movq %r15, %rbx + LONG $0xfffcefe9; BYTE $0xff // jmp LBB11_34, $-785(%rip) -LBB15_53: - LONG $0xffc5c749; WORD $0xffff; BYTE $0xff // movq $-1, %r13 - LONG $0x00000de9; BYTE $0x00 // jmp LBB15_56, $13(%rip) +LBB11_85: + WORD $0x294d; BYTE $0xee // subq %r13, %r14 + LONG $0xd075894c // movq %r14, $-48(%rbp) + LONG $0xffc3c748; WORD $0xffff; BYTE $0xff // movq $-1, %rbx + LONG $0x000014e9; BYTE $0x00 // jmp LBB11_88, $20(%rip) -LBB15_54: +LBB11_86: WORD $0xf748; BYTE $0xd0 // notq %rax - WORD $0x0149; BYTE $0xc7 // addq %rax, %r15 - -LBB15_55: - LONG $0xfec5c749; WORD $0xffff; BYTE $0xff // movq $-2, %r13 - -LBB15_56: - WORD $0x294d; BYTE $0xe7 // subq %r12, %r15 - LONG $0xd07d894c // movq %r15, $-48(%rbp) - -LBB15_57: - LONG $0xc8458b48 // movq $-56(%rbp), %rax - WORD $0x894c; BYTE $0x28 // movq %r13, (%rax) - -LBB15_58: - WORD $0x894c; BYTE $0xf8 // movq %r15, %rax - LONG $0x28c48348 // addq $40, %rsp - BYTE $0x5b // popq %rbx - WORD $0x5c41 // popq %r12 - WORD $0x5d41 // popq %r13 - WORD $0x5e41 // popq %r14 - WORD $0x5f41 // popq %r15 - BYTE $0x5d // popq %rbp - BYTE $0xc3 // retq - WORD $0x9090; BYTE $0x90 // .p2align 2, 0x90 - - // .set L15_0_set_10, LBB15_10-LJTI15_0 - // .set L15_0_set_11, LBB15_11-LJTI15_0 - // .set L15_0_set_12, LBB15_12-LJTI15_0 - // .set L15_0_set_14, LBB15_14-LJTI15_0 - // .set L15_0_set_2, LBB15_2-LJTI15_0 - // .set L15_0_set_15, LBB15_15-LJTI15_0 - // .set L15_0_set_16, LBB15_16-LJTI15_0 - // .set L15_0_set_17, LBB15_17-LJTI15_0 - // .set L15_0_set_18, LBB15_18-LJTI15_0 - // .set L15_0_set_21, LBB15_21-LJTI15_0 - // .set L15_0_set_26, LBB15_26-LJTI15_0 - // .set L15_0_set_29, LBB15_29-LJTI15_0 - // .set L15_0_set_30, LBB15_30-LJTI15_0 -LJTI15_0: - LONG $0xfffffd06 // .long L15_0_set_10 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd29 // .long L15_0_set_12 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd7e // .long L15_0_set_14 - LONG $0xfffffc6a // .long L15_0_set_2 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffc6a // .long L15_0_set_2 - LONG $0xfffffc6a // .long L15_0_set_2 - LONG $0xfffffc6a // .long L15_0_set_2 - LONG $0xfffffc6a // .long L15_0_set_2 - LONG $0xfffffc6a // .long L15_0_set_2 - LONG $0xfffffc6a // .long L15_0_set_2 - LONG $0xfffffc6a // .long L15_0_set_2 - LONG $0xfffffc6a // .long L15_0_set_2 - LONG $0xfffffc6a // .long L15_0_set_2 - LONG $0xfffffc6a // .long L15_0_set_2 - LONG $0xfffffd98 // .long L15_0_set_15 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffdb2 // .long L15_0_set_16 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffdc2 // .long L15_0_set_17 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffddc // .long L15_0_set_18 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffe12 // .long L15_0_set_21 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffe49 // .long L15_0_set_26 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffe8d // .long L15_0_set_29 - LONG $0xfffffd16 // .long L15_0_set_11 - LONG $0xfffffe9d // .long L15_0_set_30 - LONG $0x00000000 // .p2align 4, 0x00 - -LCPI16_0: - QUAD $0x2020202020202020; QUAD $0x2020202020202020 // .space 16, ' ' - -LCPI16_1: - QUAD $0x0909090909090909; QUAD $0x0909090909090909 // .space 16, '\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t' - -LCPI16_2: - QUAD $0x0a0a0a0a0a0a0a0a; QUAD $0x0a0a0a0a0a0a0a0a // .space 16, '\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n' - -LCPI16_3: - QUAD $0x0d0d0d0d0d0d0d0d; QUAD $0x0d0d0d0d0d0d0d0d // .space 16, '\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r' - - // .p2align 4, 0x90 -_advance_ns: - BYTE $0x55 // pushq %rbp - WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp - WORD $0x8b4c; BYTE $0x02 // movq (%rdx), %r8 - WORD $0x3949; BYTE $0xf0 // cmpq %rsi, %r8 - LONG $0x0029830f; WORD $0x0000 // jae LBB16_6, $41(%rip) - LONG $0x04b60f42; BYTE $0x07 // movzbl (%rdi,%r8), %eax - WORD $0xf883; BYTE $0x0d // cmpl $13, %eax - LONG $0x001b840f; WORD $0x0000 // je LBB16_6, $27(%rip) - WORD $0xf883; BYTE $0x20 // cmpl $32, %eax - LONG $0x0012840f; WORD $0x0000 // je LBB16_6, $18(%rip) - WORD $0xf504 // addb $-11, %al - WORD $0xfe3c // cmpb $-2, %al - LONG $0x0008830f; WORD $0x0000 // jae LBB16_6, $8(%rip) - WORD $0x894c; BYTE $0xc0 // movq %r8, %rax - LONG $0x000213e9; BYTE $0x00 // jmp LBB16_5, $531(%rip) - -LBB16_6: - LONG $0x01408d49 // leaq $1(%r8), %rax - WORD $0x3948; BYTE $0xf0 // cmpq %rsi, %rax - LONG $0x0022830f; WORD $0x0000 // jae LBB16_10, $34(%rip) - LONG $0x070cb60f // movzbl (%rdi,%rax), %ecx - WORD $0xf983; BYTE $0x0d // cmpl $13, %ecx - LONG $0x0015840f; WORD $0x0000 // je LBB16_10, $21(%rip) - WORD $0xf983; BYTE $0x20 // cmpl $32, %ecx - LONG $0x000c840f; WORD $0x0000 // je LBB16_10, $12(%rip) - WORD $0xc180; BYTE $0xf5 // addb $-11, %cl - WORD $0xf980; BYTE $0xfe // cmpb $-2, %cl - LONG $0x01e4820f; WORD $0x0000 // jb LBB16_5, $484(%rip) - -LBB16_10: - LONG $0x02408d49 // leaq $2(%r8), %rax - WORD $0x3948; BYTE $0xf0 // cmpq %rsi, %rax - LONG $0x0022830f; WORD $0x0000 // jae LBB16_14, $34(%rip) - LONG $0x070cb60f // movzbl (%rdi,%rax), %ecx - WORD $0xf983; BYTE $0x0d // cmpl $13, %ecx - LONG $0x0015840f; WORD $0x0000 // je LBB16_14, $21(%rip) - WORD $0xf983; BYTE $0x20 // cmpl $32, %ecx - LONG $0x000c840f; WORD $0x0000 // je LBB16_14, $12(%rip) - WORD $0xc180; BYTE $0xf5 // addb $-11, %cl - WORD $0xf980; BYTE $0xfe // cmpb $-2, %cl - LONG $0x01b5820f; WORD $0x0000 // jb LBB16_5, $437(%rip) - -LBB16_14: - LONG $0x03408d49 // leaq $3(%r8), %rax - WORD $0x3948; BYTE $0xf0 // cmpq %rsi, %rax - LONG $0x0022830f; WORD $0x0000 // jae LBB16_18, $34(%rip) - LONG $0x070cb60f // movzbl (%rdi,%rax), %ecx - WORD $0xf983; BYTE $0x0d // cmpl $13, %ecx - LONG $0x0015840f; WORD $0x0000 // je LBB16_18, $21(%rip) - WORD $0xf983; BYTE $0x20 // cmpl $32, %ecx - LONG $0x000c840f; WORD $0x0000 // je LBB16_18, $12(%rip) - WORD $0xc180; BYTE $0xf5 // addb $-11, %cl - WORD $0xf980; BYTE $0xfe // cmpb $-2, %cl - LONG $0x0186820f; WORD $0x0000 // jb LBB16_5, $390(%rip) - -LBB16_18: - LONG $0x04c08349 // addq $4, %r8 - WORD $0x3949; BYTE $0xf0 // cmpq %rsi, %r8 - LONG $0x0159830f; WORD $0x0000 // jae LBB16_19, $345(%rip) - LONG $0x070c8d4e // leaq (%rdi,%r8), %r9 - WORD $0x8949; BYTE $0xf3 // movq %rsi, %r11 - WORD $0x294d; BYTE $0xc3 // subq %r8, %r11 - LONG $0x0073840f; WORD $0x0000 // je LBB16_27, $115(%rip) - WORD $0x8944; BYTE $0xc8 // movl %r9d, %eax - WORD $0xe083; BYTE $0x0f // andl $15, %eax - LONG $0x0067840f; WORD $0x0000 // je LBB16_27, $103(%rip) - LONG $0x0005ba41; WORD $0x0000 // movl $5, %r10d - WORD $0x2949; BYTE $0xf2 // subq %rsi, %r10 - QUAD $0x000100002600b949; WORD $0x0000 // movabsq $4294977024, %r9 - QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 - -LBB16_23: - LONG $0x0cbe0f42; BYTE $0x07 // movsbl (%rdi,%r8), %ecx - WORD $0xf983; BYTE $0x20 // cmpl $32, %ecx - LONG $0x0122870f; WORD $0x0000 // ja LBB16_42, $290(%rip) - LONG $0xc9a30f49 // btq %rcx, %r9 - LONG $0x0118830f; WORD $0x0000 // jae LBB16_42, $280(%rip) - LONG $0x02048d4b // leaq (%r10,%r8), %rax - LONG $0x01488d49 // leaq $1(%r8), %rcx - LONG $0x04f88348 // cmpq $4, %rax - LONG $0x0012840f; WORD $0x0000 // je LBB16_26, $18(%rip) - LONG $0x07048d42 // leal (%rdi,%r8), %eax - WORD $0xc0ff // incl %eax - WORD $0x8949; BYTE $0xc8 // movq %rcx, %r8 - WORD $0xe083; BYTE $0x0f // andl $15, %eax - LONG $0xffc4850f; WORD $0xffff // jne LBB16_23, $-60(%rip) - -LBB16_26: - LONG $0x0f0c8d4c // leaq (%rdi,%rcx), %r9 - WORD $0x8949; BYTE $0xf3 // movq %rsi, %r11 - WORD $0x2949; BYTE $0xcb // subq %rcx, %r11 - -LBB16_27: - LONG $0x10fb8349 // cmpq $16, %r11 - LONG $0x0081820f; WORD $0x0000 // jb LBB16_33, $129(%rip) - WORD $0x8948; BYTE $0xf9 // movq %rdi, %rcx - WORD $0x294c; BYTE $0xc9 // subq %r9, %rcx - QUAD $0xfffffe52056f0f66 // movdqa $-430(%rip), %xmm0 /* LCPI16_0(%rip) */ - QUAD $0xfffffe5a0d6f0f66 // movdqa $-422(%rip), %xmm1 /* LCPI16_1(%rip) */ - QUAD $0xfffffe62156f0f66 // movdqa $-414(%rip), %xmm2 /* LCPI16_2(%rip) */ - QUAD $0xfffffe6a1d6f0f66 // movdqa $-406(%rip), %xmm3 /* LCPI16_3(%rip) */ - QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90 - -LBB16_29: - LONG $0x6f0f4166; BYTE $0x21 // movdqa (%r9), %xmm4 - LONG $0xec6f0f66 // movdqa %xmm4, %xmm5 - LONG $0xe8740f66 // pcmpeqb %xmm0, %xmm5 - LONG $0xf46f0f66 // movdqa %xmm4, %xmm6 - LONG $0xf1740f66 // pcmpeqb %xmm1, %xmm6 - LONG $0xf5eb0f66 // por %xmm5, %xmm6 - LONG $0xec6f0f66 // movdqa %xmm4, %xmm5 - LONG $0xea740f66 // pcmpeqb %xmm2, %xmm5 - LONG $0xe3740f66 // pcmpeqb %xmm3, %xmm4 - LONG $0xe5eb0f66 // por %xmm5, %xmm4 - LONG $0xe6eb0f66 // por %xmm6, %xmm4 - LONG $0xc4d70f66 // pmovmskb %xmm4, %eax - LONG $0xfff88366 // cmpw $-1, %ax - LONG $0x0069850f; WORD $0x0000 // jne LBB16_30, $105(%rip) - LONG $0x10c18349 // addq $16, %r9 - LONG $0xf0c38349 // addq $-16, %r11 - LONG $0xf0c18348 // addq $-16, %rcx - LONG $0x0ffb8349 // cmpq $15, %r11 - LONG $0xffaf870f; WORD $0xffff // ja LBB16_29, $-81(%rip) - -LBB16_33: - WORD $0x854d; BYTE $0xdb // testq %r11, %r11 - LONG $0x0037840f; WORD $0x0000 // je LBB16_40, $55(%rip) - LONG $0x19048d4f // leaq (%r9,%r11), %r8 - WORD $0xc931 // xorl %ecx, %ecx - QUAD $0x000100002600ba49; WORD $0x0000 // movabsq $4294977024, %r10 - -LBB16_35: - LONG $0x04be0f41; BYTE $0x09 // movsbl (%r9,%rcx), %eax - WORD $0xf883; BYTE $0x20 // cmpl $32, %eax - LONG $0x005b870f; WORD $0x0000 // ja LBB16_37, $91(%rip) - LONG $0xc2a30f49 // btq %rax, %r10 - LONG $0x0051830f; WORD $0x0000 // jae LBB16_37, $81(%rip) - WORD $0xff48; BYTE $0xc1 // incq %rcx - WORD $0x3949; BYTE $0xcb // cmpq %rcx, %r11 - LONG $0xffdc850f; WORD $0xffff // jne LBB16_35, $-36(%rip) - WORD $0x894d; BYTE $0xc1 // movq %r8, %r9 - -LBB16_40: - WORD $0x2949; BYTE $0xf9 // subq %rdi, %r9 + WORD $0x0149; BYTE $0xc6 // addq %rax, %r14 -LBB16_41: - WORD $0x894d; BYTE $0xc8 // movq %r9, %r8 - LONG $0x000014e9; BYTE $0x00 // jmp LBB16_42, $20(%rip) - -LBB16_19: - WORD $0x894c; BYTE $0x02 // movq %r8, (%rdx) - LONG $0x000028e9; BYTE $0x00 // jmp LBB16_43, $40(%rip) - -LBB16_30: - WORD $0xb70f; BYTE $0xc0 // movzwl %ax, %eax - WORD $0xd0f7 // notl %eax - LONG $0xc0bc0f44 // bsfl %eax, %r8d - WORD $0x2949; BYTE $0xc8 // subq %rcx, %r8 - -LBB16_42: - WORD $0x894c; BYTE $0xc0 // movq %r8, %rax - WORD $0x3949; BYTE $0xf0 // cmpq %rsi, %r8 - LONG $0x0010830f; WORD $0x0000 // jae LBB16_43, $16(%rip) - -LBB16_5: - LONG $0x01488d48 // leaq $1(%rax), %rcx - WORD $0x8948; BYTE $0x0a // movq %rcx, (%rdx) - LONG $0x0704b60f // movzbl (%rdi,%rax), %eax - WORD $0xbe0f; BYTE $0xc0 // movsbl %al, %eax - BYTE $0x5d // popq %rbp - BYTE $0xc3 // retq - -LBB16_43: - WORD $0xc031 // xorl %eax, %eax - WORD $0xbe0f; BYTE $0xc0 // movsbl %al, %eax - BYTE $0x5d // popq %rbp - BYTE $0xc3 // retq +LBB11_87: + WORD $0x294d; BYTE $0xee // subq %r13, %r14 + LONG $0xd075894c // movq %r14, $-48(%rbp) + LONG $0xfec3c748; WORD $0xffff; BYTE $0xff // movq $-2, %rbx -LBB16_37: - WORD $0x2949; BYTE $0xf9 // subq %rdi, %r9 - WORD $0x0149; BYTE $0xc9 // addq %rcx, %r9 - LONG $0xffffb6e9; BYTE $0xff // jmp LBB16_41, $-74(%rip) - WORD $0x9090 // .p2align 4, 0x90 +LBB11_88: + LONG $0xc8458b48 // movq $-56(%rbp), %rax + WORD $0x8948; BYTE $0x18 // movq %rbx, (%rax) + WORD $0x894c; BYTE $0xf3 // movq %r14, %rbx + LONG $0xfffcb9e9; BYTE $0xff // jmp LBB11_34, $-839(%rip) + WORD $0x9090 // .p2align 2, 0x90 + + // .set L11_0_set_32, LBB11_32-LJTI11_0 + // .set L11_0_set_41, LBB11_41-LJTI11_0 + // .set L11_0_set_42, LBB11_42-LJTI11_0 + // .set L11_0_set_44, LBB11_44-LJTI11_0 + // .set L11_0_set_30, LBB11_30-LJTI11_0 + // .set L11_0_set_45, LBB11_45-LJTI11_0 + // .set L11_0_set_46, LBB11_46-LJTI11_0 + // .set L11_0_set_47, LBB11_47-LJTI11_0 + // .set L11_0_set_48, LBB11_48-LJTI11_0 + // .set L11_0_set_51, LBB11_51-LJTI11_0 + // .set L11_0_set_54, LBB11_54-LJTI11_0 + // .set L11_0_set_58, LBB11_58-LJTI11_0 + // .set L11_0_set_59, LBB11_59-LJTI11_0 +LJTI11_0: + LONG $0xfffffcad // .long L11_0_set_32 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd46 // .long L11_0_set_42 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd98 // .long L11_0_set_44 + LONG $0xfffffc86 // .long L11_0_set_30 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffc86 // .long L11_0_set_30 + LONG $0xfffffc86 // .long L11_0_set_30 + LONG $0xfffffc86 // .long L11_0_set_30 + LONG $0xfffffc86 // .long L11_0_set_30 + LONG $0xfffffc86 // .long L11_0_set_30 + LONG $0xfffffc86 // .long L11_0_set_30 + LONG $0xfffffc86 // .long L11_0_set_30 + LONG $0xfffffc86 // .long L11_0_set_30 + LONG $0xfffffc86 // .long L11_0_set_30 + LONG $0xfffffc86 // .long L11_0_set_30 + LONG $0xfffffdac // .long L11_0_set_45 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffdc0 // .long L11_0_set_46 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffdcc // .long L11_0_set_47 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffde0 // .long L11_0_set_48 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffe13 // .long L11_0_set_51 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffe46 // .long L11_0_set_54 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffe89 // .long L11_0_set_58 + LONG $0xfffffd3a // .long L11_0_set_41 + LONG $0xfffffe95 // .long L11_0_set_59 + QUAD $0x9090909090909090 // .p2align 4, 0x90 _vstring: BYTE $0x55 // pushq %rbp @@ -4592,194 +4098,209 @@ _vstring: WORD $0x894c; BYTE $0xe6 // movq %r12, %rsi LONG $0x000081e8; BYTE $0x00 // callq _advance_string, $129(%rip) WORD $0x8548; BYTE $0xc0 // testq %rax, %rax - LONG $0x0029880f; WORD $0x0000 // js LBB17_1, $41(%rip) + LONG $0x0027880f; WORD $0x0000 // js LBB12_1, $39(%rip) WORD $0x8948; BYTE $0x03 // movq %rax, (%rbx) LONG $0x1066894d // movq %r12, $16(%r14) - LONG $0x0706c749; WORD $0x0000; BYTE $0x00 // movq $7, (%r14) LONG $0xd84d8b48 // movq $-40(%rbp), %rcx WORD $0x3948; BYTE $0xc1 // cmpq %rax, %rcx LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax LONG $0xc14c0f48 // cmovlq %rcx, %rax LONG $0x18468949 // movq %rax, $24(%r14) - LONG $0x00000ae9; BYTE $0x00 // jmp LBB17_3, $10(%rip) + LONG $0x000007b8; BYTE $0x00 // movl $7, %eax + LONG $0x000007e9; BYTE $0x00 // jmp LBB12_3, $7(%rip) -LBB17_1: +LBB12_1: LONG $0x084f8b49 // movq $8(%r15), %rcx WORD $0x8948; BYTE $0x0b // movq %rcx, (%rbx) - WORD $0x8949; BYTE $0x06 // movq %rax, (%r14) -LBB17_3: - LONG $0x10c48348 // addq $16, %rsp - BYTE $0x5b // popq %rbx - WORD $0x5c41 // popq %r12 - WORD $0x5e41 // popq %r14 - WORD $0x5f41 // popq %r15 - BYTE $0x5d // popq %rbp - BYTE $0xc3 // retq - QUAD $0x0000000000000000 // .p2align 4, 0x00 +LBB12_3: + WORD $0x8949; BYTE $0x06 // movq %rax, (%r14) + LONG $0x10c48348 // addq $16, %rsp + BYTE $0x5b // popq %rbx + WORD $0x5c41 // popq %r12 + WORD $0x5e41 // popq %r14 + WORD $0x5f41 // popq %r15 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + QUAD $0x0000000000000000; WORD $0x0000 // .p2align 4, 0x00 -LCPI18_0: +LCPI13_0: QUAD $0x2222222222222222; QUAD $0x2222222222222222 // .space 16, '""""""""""""""""' -LCPI18_1: +LCPI13_1: QUAD $0x5c5c5c5c5c5c5c5c; QUAD $0x5c5c5c5c5c5c5c5c // .space 16, '\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' -LCPI18_2: - QUAD $0x1f1f1f1f1f1f1f1f; QUAD $0x1f1f1f1f1f1f1f1f // .space 16, '\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f' +LCPI13_2: + QUAD $0x2020202020202020; QUAD $0x2020202020202020 // .space 16, ' ' // .p2align 4, 0x90 _advance_string: WORD $0xc1f6; BYTE $0x20 // testb $32, %cl - LONG $0x0005850f; WORD $0x0000 // jne LBB18_2, $5(%rip) - LONG $0x0045a2e9; BYTE $0x00 // jmp _advance_string_default, $17826(%rip) + LONG $0x0005850f; WORD $0x0000 // jne LBB13_2, $5(%rip) + LONG $0x0056c2e9; BYTE $0x00 // jmp _advance_string_default, $22210(%rip) -LBB18_2: - BYTE $0x55 // pushq %rbp - WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp - WORD $0x5741 // pushq %r15 - WORD $0x5641 // pushq %r14 - WORD $0x5541 // pushq %r13 - WORD $0x5441 // pushq %r12 - BYTE $0x53 // pushq %rbx - LONG $0x18ec8348 // subq $24, %rsp - LONG $0x087f8b4c // movq $8(%rdi), %r15 - WORD $0x2949; BYTE $0xf7 // subq %rsi, %r15 - LONG $0x04c3840f; WORD $0x0000 // je LBB18_47, $1219(%rip) - WORD $0x8b48; BYTE $0x07 // movq (%rdi), %rax - LONG $0xd0458948 // movq %rax, $-48(%rbp) - LONG $0xc0558948 // movq %rdx, $-64(%rbp) - LONG $0xff02c748; WORD $0xffff; BYTE $0xff // movq $-1, (%rdx) - LONG $0x40ff8349 // cmpq $64, %r15 - LONG $0x03d0820f; WORD $0x0000 // jb LBB18_48, $976(%rip) - QUAD $0xffffffffc845c748 // movq $-1, $-56(%rbp) - WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d - QUAD $0xffff74056f0f4466; BYTE $0xff // movdqa $-140(%rip), %xmm8 /* LCPI18_0(%rip) */ - QUAD $0xffff7b0d6f0f4466; BYTE $0xff // movdqa $-133(%rip), %xmm9 /* LCPI18_1(%rip) */ - QUAD $0xffff82156f0f4466; BYTE $0xff // movdqa $-126(%rip), %xmm10 /* LCPI18_2(%rip) */ - WORD $0x9090 // .p2align 4, 0x90 +LBB13_2: + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5741 // pushq %r15 + WORD $0x5641 // pushq %r14 + WORD $0x5541 // pushq %r13 + WORD $0x5441 // pushq %r12 + BYTE $0x53 // pushq %rbx + LONG $0x20ec8348 // subq $32, %rsp + LONG $0x085f8b48 // movq $8(%rdi), %rbx + WORD $0x2948; BYTE $0xf3 // subq %rsi, %rbx + LONG $0x051e840f; WORD $0x0000 // je LBB13_21, $1310(%rip) + WORD $0x8b48; BYTE $0x07 // movq (%rdi), %rax + LONG $0xc0458948 // movq %rax, $-64(%rbp) + WORD $0x0148; BYTE $0xc6 // addq %rax, %rsi + LONG $0xc8558948 // movq %rdx, $-56(%rbp) + LONG $0xff02c748; WORD $0xffff; BYTE $0xff // movq $-1, (%rdx) + LONG $0x40fb8348 // cmpq $64, %rbx + LONG $0x0285820f; WORD $0x0000 // jb LBB13_22, $645(%rip) + QUAD $0xffffffffd045c748 // movq $-1, $-48(%rbp) + WORD $0x3145; BYTE $0xff // xorl %r15d, %r15d + QUAD $0xffff71056f0f4466; BYTE $0xff // movdqa $-143(%rip), %xmm8 /* LCPI13_0(%rip) */ + QUAD $0xffffff790d6f0f66 // movdqa $-135(%rip), %xmm1 /* LCPI13_1(%rip) */ + QUAD $0xffffff81156f0f66 // movdqa $-127(%rip), %xmm2 /* LCPI13_2(%rip) */ + LONG $0xdb760f66 // pcmpeqd %xmm3, %xmm3 + QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 -LBB18_5: - LONG $0xd0458b48 // movq $-48(%rbp), %rax - LONG $0x1c6f0ff3; BYTE $0x30 // movdqu (%rax,%rsi), %xmm3 - LONG $0x446f0ff3; WORD $0x1030 // movdqu $16(%rax,%rsi), %xmm0 - LONG $0x4c6f0ff3; WORD $0x2030 // movdqu $32(%rax,%rsi), %xmm1 - LONG $0x546f0ff3; WORD $0x3030 // movdqu $48(%rax,%rsi), %xmm2 - LONG $0xfb6f0f66 // movdqa %xmm3, %xmm7 +LBB13_5: + LONG $0xb85d8948 // movq %rbx, $-72(%rbp) + LONG $0x066f0ff3 // movdqu (%rsi), %xmm0 + LONG $0x766f0ff3; BYTE $0x10 // movdqu $16(%rsi), %xmm6 + LONG $0x6e6f0ff3; BYTE $0x20 // movdqu $32(%rsi), %xmm5 + LONG $0x666f0ff3; BYTE $0x30 // movdqu $48(%rsi), %xmm4 + LONG $0xf86f0f66 // movdqa %xmm0, %xmm7 + LONG $0x740f4166; BYTE $0xf8 // pcmpeqb %xmm8, %xmm7 + LONG $0xffd70f66 // pmovmskb %xmm7, %edi + LONG $0xfe6f0f66 // movdqa %xmm6, %xmm7 + LONG $0x740f4166; BYTE $0xf8 // pcmpeqb %xmm8, %xmm7 + LONG $0xd70f4466; BYTE $0xcf // pmovmskb %xmm7, %r9d + LONG $0xfd6f0f66 // movdqa %xmm5, %xmm7 + LONG $0x740f4166; BYTE $0xf8 // pcmpeqb %xmm8, %xmm7 + LONG $0xd70f4466; BYTE $0xd7 // pmovmskb %xmm7, %r10d + LONG $0xfc6f0f66 // movdqa %xmm4, %xmm7 LONG $0x740f4166; BYTE $0xf8 // pcmpeqb %xmm8, %xmm7 - LONG $0xd70f4466; BYTE $0xe7 // pmovmskb %xmm7, %r12d + LONG $0xd70f4466; BYTE $0xdf // pmovmskb %xmm7, %r11d LONG $0xf86f0f66 // movdqa %xmm0, %xmm7 - LONG $0xf06f0f66 // movdqa %xmm0, %xmm6 - LONG $0xda0f4166; BYTE $0xf2 // pminub %xmm10, %xmm6 - LONG $0xf0740f66 // pcmpeqb %xmm0, %xmm6 - LONG $0x740f4166; BYTE $0xc0 // pcmpeqb %xmm8, %xmm0 - LONG $0xd70f4466; BYTE $0xc0 // pmovmskb %xmm0, %r8d - LONG $0xc16f0f66 // movdqa %xmm1, %xmm0 - LONG $0xe96f0f66 // movdqa %xmm1, %xmm5 - LONG $0xda0f4166; BYTE $0xea // pminub %xmm10, %xmm5 - LONG $0xe9740f66 // pcmpeqb %xmm1, %xmm5 - LONG $0x740f4166; BYTE $0xc8 // pcmpeqb %xmm8, %xmm1 - LONG $0xd70f4466; BYTE $0xc9 // pmovmskb %xmm1, %r9d - LONG $0xca6f0f66 // movdqa %xmm2, %xmm1 - LONG $0xe26f0f66 // movdqa %xmm2, %xmm4 - LONG $0xda0f4166; BYTE $0xe2 // pminub %xmm10, %xmm4 - LONG $0xe2740f66 // pcmpeqb %xmm2, %xmm4 - LONG $0x740f4166; BYTE $0xd0 // pcmpeqb %xmm8, %xmm2 - LONG $0xd70f4466; BYTE $0xd2 // pmovmskb %xmm2, %r10d - LONG $0xd36f0f66 // movdqa %xmm3, %xmm2 - LONG $0x740f4166; BYTE $0xd1 // pcmpeqb %xmm9, %xmm2 - LONG $0xd70f4466; BYTE $0xea // pmovmskb %xmm2, %r13d - LONG $0x740f4166; BYTE $0xf9 // pcmpeqb %xmm9, %xmm7 + LONG $0xf9740f66 // pcmpeqb %xmm1, %xmm7 + LONG $0xc7d70f66 // pmovmskb %xmm7, %eax + LONG $0xfe6f0f66 // movdqa %xmm6, %xmm7 + LONG $0xf9740f66 // pcmpeqb %xmm1, %xmm7 LONG $0xcfd70f66 // pmovmskb %xmm7, %ecx - LONG $0x740f4166; BYTE $0xc1 // pcmpeqb %xmm9, %xmm0 - LONG $0xd70f4466; BYTE $0xd8 // pmovmskb %xmm0, %r11d - LONG $0x740f4166; BYTE $0xc9 // pcmpeqb %xmm9, %xmm1 - LONG $0xd1d70f66 // pmovmskb %xmm1, %edx - LONG $0xded70f66 // pmovmskb %xmm6, %ebx - LONG $0xc5d70f66 // pmovmskb %xmm5, %eax - LONG $0xfcd70f66 // pmovmskb %xmm4, %edi - LONG $0x30e2c149 // shlq $48, %r10 - LONG $0x20e1c149 // shlq $32, %r9 - WORD $0x094d; BYTE $0xd1 // orq %r10, %r9 - LONG $0x10e0c149 // shlq $16, %r8 - WORD $0x094d; BYTE $0xc8 // orq %r9, %r8 - WORD $0x094d; BYTE $0xc4 // orq %r8, %r12 - LONG $0x30e2c148 // shlq $48, %rdx - LONG $0x20e3c149 // shlq $32, %r11 - WORD $0x0949; BYTE $0xd3 // orq %rdx, %r11 + LONG $0xfd6f0f66 // movdqa %xmm5, %xmm7 + LONG $0xf9740f66 // pcmpeqb %xmm1, %xmm7 + LONG $0xd70f4466; BYTE $0xc7 // pmovmskb %xmm7, %r8d + LONG $0xfc6f0f66 // movdqa %xmm4, %xmm7 + LONG $0xf9740f66 // pcmpeqb %xmm1, %xmm7 + LONG $0xd70f4466; BYTE $0xef // pmovmskb %xmm7, %r13d + LONG $0xfa6f0f66 // movdqa %xmm2, %xmm7 + LONG $0xf8640f66 // pcmpgtb %xmm0, %xmm7 + LONG $0xc3640f66 // pcmpgtb %xmm3, %xmm0 + LONG $0xc7db0f66 // pand %xmm7, %xmm0 + LONG $0xd8d70f66 // pmovmskb %xmm0, %ebx + LONG $0xc26f0f66 // movdqa %xmm2, %xmm0 + LONG $0xc6640f66 // pcmpgtb %xmm6, %xmm0 + LONG $0xf3640f66 // pcmpgtb %xmm3, %xmm6 + LONG $0xf0db0f66 // pand %xmm0, %xmm6 + LONG $0xd70f4466; BYTE $0xf6 // pmovmskb %xmm6, %r14d + LONG $0xc26f0f66 // movdqa %xmm2, %xmm0 + LONG $0xc5640f66 // pcmpgtb %xmm5, %xmm0 + LONG $0xeb640f66 // pcmpgtb %xmm3, %xmm5 + LONG $0xe8db0f66 // pand %xmm0, %xmm5 + LONG $0xd5d70f66 // pmovmskb %xmm5, %edx + LONG $0xc26f0f66 // movdqa %xmm2, %xmm0 + LONG $0xc4640f66 // pcmpgtb %xmm4, %xmm0 + LONG $0xe3640f66 // pcmpgtb %xmm3, %xmm4 + LONG $0xe0db0f66 // pand %xmm0, %xmm4 + LONG $0xd70f4466; BYTE $0xe4 // pmovmskb %xmm4, %r12d + LONG $0x30e3c149 // shlq $48, %r11 + LONG $0x20e2c149 // shlq $32, %r10 + LONG $0x10e1c149 // shlq $16, %r9 + WORD $0x094c; BYTE $0xcf // orq %r9, %rdi + WORD $0x094c; BYTE $0xd7 // orq %r10, %rdi + WORD $0x094c; BYTE $0xdf // orq %r11, %rdi + LONG $0x30e5c149 // shlq $48, %r13 + LONG $0x20e0c149 // shlq $32, %r8 LONG $0x10e1c148 // shlq $16, %rcx - WORD $0x094c; BYTE $0xd9 // orq %r11, %rcx - LONG $0x30e7c148 // shlq $48, %rdi - LONG $0x20e0c148 // shlq $32, %rax - WORD $0x0948; BYTE $0xf8 // orq %rdi, %rax - LONG $0x10e3c148 // shlq $16, %rbx - WORD $0x0948; BYTE $0xc3 // orq %rax, %rbx - WORD $0x0949; BYTE $0xcd // orq %rcx, %r13 - LONG $0x0049850f; WORD $0x0000 // jne LBB18_11, $73(%rip) - WORD $0x854d; BYTE $0xf6 // testq %r14, %r14 - LONG $0x005d850f; WORD $0x0000 // jne LBB18_13, $93(%rip) - WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d + WORD $0x0948; BYTE $0xc8 // orq %rcx, %rax + WORD $0x094c; BYTE $0xc0 // orq %r8, %rax + LONG $0x30e4c149 // shlq $48, %r12 + LONG $0x20e2c148 // shlq $32, %rdx + LONG $0x10e6c149 // shlq $16, %r14 + WORD $0x094c; BYTE $0xf3 // orq %r14, %rbx + WORD $0x0948; BYTE $0xd3 // orq %rdx, %rbx + WORD $0x094c; BYTE $0xe8 // orq %r13, %rax + LONG $0x003c850f; WORD $0x0000 // jne LBB13_10, $60(%rip) + WORD $0x854d; BYTE $0xff // testq %r15, %r15 + LONG $0x0057850f; WORD $0x0000 // jne LBB13_12, $87(%rip) + WORD $0x3145; BYTE $0xff // xorl %r15d, %r15d + WORD $0x094c; BYTE $0xe3 // orq %r12, %rbx + WORD $0x8548; BYTE $0xff // testq %rdi, %rdi + LONG $0x009d850f; WORD $0x0000 // jne LBB13_13, $157(%rip) -LBB18_8: - LONG $0xc36f0f66 // movdqa %xmm3, %xmm0 - LONG $0xda0f4166; BYTE $0xc2 // pminub %xmm10, %xmm0 - LONG $0xc3740f66 // pcmpeqb %xmm3, %xmm0 - LONG $0xc0d70f66 // pmovmskb %xmm0, %eax - WORD $0x0948; BYTE $0xc3 // orq %rax, %rbx - WORD $0x854d; BYTE $0xe4 // testq %r12, %r12 - LONG $0x008b850f; WORD $0x0000 // jne LBB18_14, $139(%rip) +LBB13_8: WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx - LONG $0x00d5850f; WORD $0x0000 // jne LBB18_20, $213(%rip) - LONG $0xc0c78349 // addq $-64, %r15 + LONG $0x00f2850f; WORD $0x0000 // jne LBB13_19, $242(%rip) LONG $0x40c68348 // addq $64, %rsi - LONG $0x3fff8349 // cmpq $63, %r15 - LONG $0xfeca870f; WORD $0xffff // ja LBB18_5, $-310(%rip) - LONG $0x0000e3e9; BYTE $0x00 // jmp LBB18_22, $227(%rip) + LONG $0xb85d8b48 // movq $-72(%rbp), %rbx + LONG $0xc0c38348 // addq $-64, %rbx + LONG $0x3ffb8348 // cmpq $63, %rbx + LONG $0xfeb5870f; WORD $0xffff // ja LBB13_5, $-331(%rip) + LONG $0x00010be9; BYTE $0x00 // jmp LBB13_23, $267(%rip) -LBB18_11: - LONG $0xc87d8348; BYTE $0xff // cmpq $-1, $-56(%rbp) - LONG $0x0012850f; WORD $0x0000 // jne LBB18_13, $18(%rip) - LONG $0xcdbc0f49 // bsfq %r13, %rcx - WORD $0x0148; BYTE $0xf1 // addq %rsi, %rcx - LONG $0xc0458b48 // movq $-64(%rbp), %rax - LONG $0xc84d8948 // movq %rcx, $-56(%rbp) - WORD $0x8948; BYTE $0x08 // movq %rcx, (%rax) +LBB13_10: + LONG $0xd07d8348; BYTE $0xff // cmpq $-1, $-48(%rbp) + LONG $0x0019850f; WORD $0x0000 // jne LBB13_12, $25(%rip) + WORD $0x8948; BYTE $0xf1 // movq %rsi, %rcx + LONG $0xc04d2b48 // subq $-64(%rbp), %rcx + LONG $0xd0bc0f48 // bsfq %rax, %rdx + WORD $0x0148; BYTE $0xca // addq %rcx, %rdx + LONG $0xc84d8b48 // movq $-56(%rbp), %rcx + LONG $0xd0558948 // movq %rdx, $-48(%rbp) + WORD $0x8948; BYTE $0x11 // movq %rdx, (%rcx) -LBB18_13: - WORD $0x894c; BYTE $0xf0 // movq %r14, %rax - WORD $0xf748; BYTE $0xd0 // notq %rax - WORD $0x214c; BYTE $0xe8 // andq %r13, %rax - LONG $0x000c8d48 // leaq (%rax,%rax), %rcx - WORD $0x094c; BYTE $0xf1 // orq %r14, %rcx - WORD $0x8948; BYTE $0xca // movq %rcx, %rdx +LBB13_12: + WORD $0x894c; BYTE $0xf9 // movq %r15, %rcx + WORD $0xf748; BYTE $0xd1 // notq %rcx + WORD $0x2148; BYTE $0xc1 // andq %rax, %rcx + LONG $0x09048d4c // leaq (%rcx,%rcx), %r8 + WORD $0x094d; BYTE $0xf8 // orq %r15, %r8 + WORD $0x894c; BYTE $0xc2 // movq %r8, %rdx WORD $0xf748; BYTE $0xd2 // notq %rdx - WORD $0x214c; BYTE $0xea // andq %r13, %rdx - QUAD $0xaaaaaaaaaaaabf48; WORD $0xaaaa // movabsq $-6148914691236517206, %rdi - WORD $0x2148; BYTE $0xfa // andq %rdi, %rdx - WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d - WORD $0x0148; BYTE $0xc2 // addq %rax, %rdx - LONG $0xc6920f41 // setb %r14b + WORD $0x2148; BYTE $0xc2 // andq %rax, %rdx + QUAD $0xaaaaaaaaaaaab848; WORD $0xaaaa // movabsq $-6148914691236517206, %rax + WORD $0x2148; BYTE $0xc2 // andq %rax, %rdx + WORD $0x3145; BYTE $0xff // xorl %r15d, %r15d + WORD $0x0148; BYTE $0xca // addq %rcx, %rdx + LONG $0xc7920f41 // setb %r15b WORD $0x0148; BYTE $0xd2 // addq %rdx, %rdx - QUAD $0x555555555555b848; WORD $0x5555 // movabsq $6148914691236517205, %rax - WORD $0x3148; BYTE $0xc2 // xorq %rax, %rdx - WORD $0x2148; BYTE $0xca // andq %rcx, %rdx + QUAD $0x555555555555b948; WORD $0x5555 // movabsq $6148914691236517205, %rcx + WORD $0x3148; BYTE $0xca // xorq %rcx, %rdx + WORD $0x214c; BYTE $0xc2 // andq %r8, %rdx WORD $0xf748; BYTE $0xd2 // notq %rdx - WORD $0x2149; BYTE $0xd4 // andq %rdx, %r12 - LONG $0xffff58e9; BYTE $0xff // jmp LBB18_8, $-168(%rip) + WORD $0x2148; BYTE $0xd7 // andq %rdx, %rdi + WORD $0x094c; BYTE $0xe3 // orq %r12, %rbx + WORD $0x8548; BYTE $0xff // testq %rdi, %rdi + LONG $0xff63840f; WORD $0xffff // je LBB13_8, $-157(%rip) -LBB18_14: - LONG $0xc4bc0f49 // bsfq %r12, %rax +LBB13_13: + LONG $0xc7bc0f48 // bsfq %rdi, %rax WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx - LONG $0x0022840f; WORD $0x0000 // je LBB18_18, $34(%rip) + LONG $0x0029840f; WORD $0x0000 // je LBB13_17, $41(%rip) LONG $0xcbbc0f48 // bsfq %rbx, %rcx + LONG $0xc8558b48 // movq $-56(%rbp), %rdx + LONG $0xc0752b48 // subq $-64(%rbp), %rsi WORD $0x3948; BYTE $0xc1 // cmpq %rax, %rcx - LONG $0x0023820f; WORD $0x0000 // jb LBB18_19, $35(%rip) + LONG $0x002a820f; WORD $0x0000 // jb LBB13_18, $42(%rip) -LBB18_16: - WORD $0x0148; BYTE $0xf0 // addq %rsi, %rax - WORD $0xff48; BYTE $0xc0 // incq %rax +LBB13_15: + LONG $0x06448d48; BYTE $0x01 // leaq $1(%rsi,%rax), %rax -LBB18_17: - LONG $0x18c48348 // addq $24, %rsp +LBB13_16: + LONG $0x20c48348 // addq $32, %rsp BYTE $0x5b // popq %rbx WORD $0x5c41 // popq %r12 WORD $0x5d41 // popq %r13 @@ -4788,232 +4309,244 @@ LBB18_17: BYTE $0x5d // popq %rbp BYTE $0xc3 // retq -LBB18_18: +LBB13_17: LONG $0x000040b9; BYTE $0x00 // movl $64, %ecx + LONG $0xc8558b48 // movq $-56(%rbp), %rdx + LONG $0xc0752b48 // subq $-64(%rbp), %rsi WORD $0x3948; BYTE $0xc1 // cmpq %rax, %rcx - LONG $0xffdd830f; WORD $0xffff // jae LBB18_16, $-35(%rip) + LONG $0xffd6830f; WORD $0xffff // jae LBB13_15, $-42(%rip) -LBB18_19: +LBB13_18: WORD $0x0148; BYTE $0xf1 // addq %rsi, %rcx - LONG $0xc0458b48 // movq $-64(%rbp), %rax - WORD $0x8948; BYTE $0x08 // movq %rcx, (%rax) + WORD $0x8948; BYTE $0x0a // movq %rcx, (%rdx) LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq $-2, %rax - LONG $0xffffcde9; BYTE $0xff // jmp LBB18_17, $-51(%rip) + LONG $0xffffc9e9; BYTE $0xff // jmp LBB13_16, $-55(%rip) -LBB18_20: +LBB13_19: LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq $-2, %rax - LONG $0xc87d8348; BYTE $0xff // cmpq $-1, $-56(%rbp) - LONG $0xffbb850f; WORD $0xffff // jne LBB18_17, $-69(%rip) + LONG $0xd07d8348; BYTE $0xff // cmpq $-1, $-48(%rbp) + LONG $0xffb7850f; WORD $0xffff // jne LBB13_16, $-73(%rip) LONG $0xcbbc0f48 // bsfq %rbx, %rcx - WORD $0x0148; BYTE $0xf1 // addq %rsi, %rcx - LONG $0xc0558b48 // movq $-64(%rbp), %rdx - WORD $0x8948; BYTE $0x0a // movq %rcx, (%rdx) - LONG $0xffffa8e9; BYTE $0xff // jmp LBB18_17, $-88(%rip) + LONG $0xc0752b48 // subq $-64(%rbp), %rsi + WORD $0x0148; BYTE $0xce // addq %rcx, %rsi + LONG $0xc84d8b48 // movq $-56(%rbp), %rcx + WORD $0x8948; BYTE $0x31 // movq %rsi, (%rcx) + LONG $0xffffa0e9; BYTE $0xff // jmp LBB13_16, $-96(%rip) -LBB18_22: - LONG $0xd0750348 // addq $-48(%rbp), %rsi - LONG $0x20ff8349 // cmpq $32, %r15 - LONG $0x00e1820f; WORD $0x0000 // jb LBB18_35, $225(%rip) +LBB13_22: + QUAD $0xffffffffd045c748 // movq $-1, $-48(%rbp) + WORD $0x3145; BYTE $0xff // xorl %r15d, %r15d -LBB18_23: +LBB13_23: + LONG $0x20fb8348 // cmpq $32, %rbx + LONG $0x00f0820f; WORD $0x0000 // jb LBB13_36, $240(%rip) LONG $0x066f0ff3 // movdqu (%rsi), %xmm0 - QUAD $0xfffffd280d6f0f66 // movdqa $-728(%rip), %xmm1 /* LCPI18_0(%rip) */ - LONG $0xd06f0f66 // movdqa %xmm0, %xmm2 - QUAD $0xfffffd3c1d6f0f66 // movdqa $-708(%rip), %xmm3 /* LCPI18_2(%rip) */ - LONG $0xe06f0f66 // movdqa %xmm0, %xmm4 - LONG $0xe3da0f66 // pminub %xmm3, %xmm4 - LONG $0xe0740f66 // pcmpeqb %xmm0, %xmm4 - LONG $0xc1740f66 // pcmpeqb %xmm1, %xmm0 - LONG $0xc0d70f66 // pmovmskb %xmm0, %eax - LONG $0x466f0ff3; BYTE $0x10 // movdqu $16(%rsi), %xmm0 - LONG $0xc8740f66 // pcmpeqb %xmm0, %xmm1 - LONG $0xc9d70f66 // pmovmskb %xmm1, %ecx - QUAD $0xfffffd030d6f0f66 // movdqa $-765(%rip), %xmm1 /* LCPI18_1(%rip) */ + LONG $0x4e6f0ff3; BYTE $0x10 // movdqu $16(%rsi), %xmm1 + QUAD $0xfffffcda156f0f66 // movdqa $-806(%rip), %xmm2 /* LCPI13_0(%rip) */ + LONG $0xd86f0f66 // movdqa %xmm0, %xmm3 + LONG $0xda740f66 // pcmpeqb %xmm2, %xmm3 + LONG $0xd70f4466; BYTE $0xdb // pmovmskb %xmm3, %r11d LONG $0xd1740f66 // pcmpeqb %xmm1, %xmm2 - LONG $0xd70f4466; BYTE $0xd2 // pmovmskb %xmm2, %r10d - LONG $0xc8740f66 // pcmpeqb %xmm0, %xmm1 - LONG $0xd1d70f66 // pmovmskb %xmm1, %edx - LONG $0xd70f4466; BYTE $0xcc // pmovmskb %xmm4, %r9d - LONG $0xd8da0f66 // pminub %xmm0, %xmm3 - LONG $0xd8740f66 // pcmpeqb %xmm0, %xmm3 - LONG $0xdbd70f66 // pmovmskb %xmm3, %ebx - LONG $0x10e1c148 // shlq $16, %rcx - WORD $0x0948; BYTE $0xc8 // orq %rcx, %rax + LONG $0xd2d70f66 // pmovmskb %xmm2, %edx + QUAD $0xfffffccd156f0f66 // movdqa $-819(%rip), %xmm2 /* LCPI13_1(%rip) */ + LONG $0xd86f0f66 // movdqa %xmm0, %xmm3 + LONG $0xda740f66 // pcmpeqb %xmm2, %xmm3 + LONG $0xd70f4466; BYTE $0xd3 // pmovmskb %xmm3, %r10d + LONG $0xd1740f66 // pcmpeqb %xmm1, %xmm2 + LONG $0xcad70f66 // pmovmskb %xmm2, %ecx + QUAD $0xfffffcc0156f0f66 // movdqa $-832(%rip), %xmm2 /* LCPI13_2(%rip) */ + LONG $0xda6f0f66 // movdqa %xmm2, %xmm3 + LONG $0xd8640f66 // pcmpgtb %xmm0, %xmm3 + LONG $0xe4760f66 // pcmpeqd %xmm4, %xmm4 + LONG $0xc4640f66 // pcmpgtb %xmm4, %xmm0 + LONG $0xc3db0f66 // pand %xmm3, %xmm0 + LONG $0xd70f4466; BYTE $0xc0 // pmovmskb %xmm0, %r8d + LONG $0xd1640f66 // pcmpgtb %xmm1, %xmm2 + LONG $0xcc640f66 // pcmpgtb %xmm4, %xmm1 + LONG $0xcadb0f66 // pand %xmm2, %xmm1 + LONG $0xf9d70f66 // pmovmskb %xmm1, %edi LONG $0x10e2c148 // shlq $16, %rdx - LONG $0x10e3c148 // shlq $16, %rbx - WORD $0x0949; BYTE $0xd2 // orq %rdx, %r10 - LONG $0x011f850f; WORD $0x0000 // jne LBB18_49, $287(%rip) - WORD $0x854d; BYTE $0xf6 // testq %r14, %r14 - LONG $0x013a850f; WORD $0x0000 // jne LBB18_51, $314(%rip) - WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d + WORD $0x0949; BYTE $0xd3 // orq %rdx, %r11 + LONG $0x10e1c148 // shlq $16, %rcx + LONG $0x10e7c148 // shlq $16, %rdi + WORD $0x0949; BYTE $0xca // orq %rcx, %r10 + LONG $0x0111850f; WORD $0x0000 // jne LBB13_48, $273(%rip) + WORD $0x854d; BYTE $0xff // testq %r15, %r15 + LONG $0x012c850f; WORD $0x0000 // jne LBB13_50, $300(%rip) + WORD $0x3145; BYTE $0xff // xorl %r15d, %r15d -LBB18_26: - WORD $0x094c; BYTE $0xcb // orq %r9, %rbx +LBB13_27: + WORD $0x094c; BYTE $0xc7 // orq %r8, %rdi LONG $0x000040b9; BYTE $0x00 // movl $64, %ecx LONG $0x000040ba; BYTE $0x00 // movl $64, %edx - WORD $0x8548; BYTE $0xc0 // testq %rax, %rax - LONG $0x0004840f; WORD $0x0000 // je LBB18_28, $4(%rip) - LONG $0xd0bc0f48 // bsfq %rax, %rdx + WORD $0x854d; BYTE $0xdb // testq %r11, %r11 + LONG $0x0004840f; WORD $0x0000 // je LBB13_29, $4(%rip) + LONG $0xd3bc0f49 // bsfq %r11, %rdx -LBB18_28: - WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx - LONG $0x0004840f; WORD $0x0000 // je LBB18_30, $4(%rip) - LONG $0xcbbc0f48 // bsfq %rbx, %rcx +LBB13_29: + WORD $0x8548; BYTE $0xff // testq %rdi, %rdi + LONG $0x0004840f; WORD $0x0000 // je LBB13_31, $4(%rip) + LONG $0xcfbc0f48 // bsfq %rdi, %rcx -LBB18_30: - WORD $0x8548; BYTE $0xc0 // testq %rax, %rax - LONG $0x0019840f; WORD $0x0000 // je LBB18_33, $25(%rip) +LBB13_31: + WORD $0x854d; BYTE $0xdb // testq %r11, %r11 + LONG $0x0017840f; WORD $0x0000 // je LBB13_34, $23(%rip) + LONG $0xc0752b48 // subq $-64(%rbp), %rsi WORD $0x3948; BYTE $0xd1 // cmpq %rdx, %rcx - LONG $0x0135820f; WORD $0x0000 // jb LBB18_52, $309(%rip) - LONG $0xd0752b48 // subq $-48(%rbp), %rsi - LONG $0x16048d48 // leaq (%rsi,%rdx), %rax - WORD $0xff48; BYTE $0xc0 // incq %rax - LONG $0xfffecae9; BYTE $0xff // jmp LBB18_17, $-310(%rip) + LONG $0x0124820f; WORD $0x0000 // jb LBB13_51, $292(%rip) + LONG $0x16448d48; BYTE $0x01 // leaq $1(%rsi,%rdx), %rax + LONG $0xfffeace9; BYTE $0xff // jmp LBB13_16, $-340(%rip) -LBB18_33: - WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx - LONG $0x011c850f; WORD $0x0000 // jne LBB18_52, $284(%rip) +LBB13_34: + WORD $0x8548; BYTE $0xff // testq %rdi, %rdi + LONG $0x0127850f; WORD $0x0000 // jne LBB13_52, $295(%rip) LONG $0x20c68348 // addq $32, %rsi - LONG $0xe0c78349 // addq $-32, %r15 + LONG $0xe0c38348 // addq $-32, %rbx -LBB18_35: - WORD $0x854d; BYTE $0xf6 // testq %r14, %r14 - LONG $0x0125850f; WORD $0x0000 // jne LBB18_54, $293(%rip) - LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax +LBB13_36: WORD $0x854d; BYTE $0xff // testq %r15, %r15 - LONG $0xfea0840f; WORD $0xffff // je LBB18_17, $-352(%rip) + LONG $0x0122850f; WORD $0x0000 // jne LBB13_53, $290(%rip) + LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax + WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx + LONG $0xfe82840f; WORD $0xffff // je LBB13_16, $-382(%rip) -LBB18_37: - LONG $0xc0558b48 // movq $-64(%rbp), %rdx +LBB13_38: + LONG $0xc87d8b48 // movq $-56(%rbp), %rdi -LBB18_38: +LBB13_39: WORD $0xb60f; BYTE $0x0e // movzbl (%rsi), %ecx - WORD $0xf983; BYTE $0x22 // cmpl $34, %ecx - LONG $0x0063840f; WORD $0x0000 // je LBB18_46, $99(%rip) - WORD $0xf983; BYTE $0x5c // cmpl $92, %ecx - LONG $0x0026840f; WORD $0x0000 // je LBB18_43, $38(%rip) + WORD $0xf980; BYTE $0x22 // cmpb $34, %cl + LONG $0x0075840f; WORD $0x0000 // je LBB13_47, $117(%rip) + WORD $0xf980; BYTE $0x5c // cmpb $92, %cl + LONG $0x0026840f; WORD $0x0000 // je LBB13_43, $38(%rip) WORD $0xf980; BYTE $0x1f // cmpb $31, %cl - LONG $0x0143860f; WORD $0x0000 // jbe LBB18_58, $323(%rip) + LONG $0x0146860f; WORD $0x0000 // jbe LBB13_57, $326(%rip) LONG $0xffc1c748; WORD $0xffff; BYTE $0xff // movq $-1, %rcx - LONG $0x000001bf; BYTE $0x00 // movl $1, %edi - -LBB18_42: - WORD $0x0148; BYTE $0xfe // addq %rdi, %rsi - WORD $0x0149; BYTE $0xcf // addq %rcx, %r15 - LONG $0xffca850f; WORD $0xffff // jne LBB18_38, $-54(%rip) - LONG $0xfffe61e9; BYTE $0xff // jmp LBB18_17, $-415(%rip) + LONG $0x000001ba; BYTE $0x00 // movl $1, %edx + WORD $0x0148; BYTE $0xd6 // addq %rdx, %rsi + WORD $0x0148; BYTE $0xcb // addq %rcx, %rbx + LONG $0xffca850f; WORD $0xffff // jne LBB13_39, $-54(%rip) + LONG $0xfffe43e9; BYTE $0xff // jmp LBB13_16, $-445(%rip) -LBB18_43: - LONG $0x01ff8349 // cmpq $1, %r15 - LONG $0xfe57840f; WORD $0xffff // je LBB18_17, $-425(%rip) +LBB13_43: + LONG $0x01fb8348 // cmpq $1, %rbx + LONG $0xfe39840f; WORD $0xffff // je LBB13_16, $-455(%rip) + WORD $0x8949; BYTE $0xd8 // movq %rbx, %r8 LONG $0xfec1c748; WORD $0xffff; BYTE $0xff // movq $-2, %rcx - LONG $0x000002bf; BYTE $0x00 // movl $2, %edi - LONG $0xc87d8348; BYTE $0xff // cmpq $-1, $-56(%rbp) - LONG $0xffce850f; WORD $0xffff // jne LBB18_42, $-50(%rip) + LONG $0x000002ba; BYTE $0x00 // movl $2, %edx + LONG $0xd07d8348; BYTE $0xff // cmpq $-1, $-48(%rbp) + LONG $0x000e850f; WORD $0x0000 // jne LBB13_46, $14(%rip) WORD $0x8948; BYTE $0xf3 // movq %rsi, %rbx - LONG $0xd05d2b48 // subq $-48(%rbp), %rbx - LONG $0xc85d8948 // movq %rbx, $-56(%rbp) - WORD $0x8948; BYTE $0x1a // movq %rbx, (%rdx) - LONG $0xffffbbe9; BYTE $0xff // jmp LBB18_42, $-69(%rip) + LONG $0xc05d2b48 // subq $-64(%rbp), %rbx + LONG $0xd05d8948 // movq %rbx, $-48(%rbp) + WORD $0x8948; BYTE $0x1f // movq %rbx, (%rdi) + +LBB13_46: + WORD $0x894c; BYTE $0xc3 // movq %r8, %rbx + WORD $0x0148; BYTE $0xd6 // addq %rdx, %rsi + WORD $0x0148; BYTE $0xcb // addq %rcx, %rbx + LONG $0xff84850f; WORD $0xffff // jne LBB13_39, $-124(%rip) + LONG $0xfffdfde9; BYTE $0xff // jmp LBB13_16, $-515(%rip) -LBB18_46: - LONG $0xd0752b48 // subq $-48(%rbp), %rsi +LBB13_47: + LONG $0xc0752b48 // subq $-64(%rbp), %rsi WORD $0xff48; BYTE $0xc6 // incq %rsi WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax - LONG $0xfffe1ee9; BYTE $0xff // jmp LBB18_17, $-482(%rip) - -LBB18_48: - LONG $0xd0750348 // addq $-48(%rbp), %rsi - QUAD $0xffffffffc845c748 // movq $-1, $-56(%rbp) - WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d - LONG $0x20ff8349 // cmpq $32, %r15 - LONG $0xfe6b830f; WORD $0xffff // jae LBB18_23, $-405(%rip) - LONG $0xffff47e9; BYTE $0xff // jmp LBB18_35, $-185(%rip) + LONG $0xfffdeee9; BYTE $0xff // jmp LBB13_16, $-530(%rip) -LBB18_49: - LONG $0xc87d8348; BYTE $0xff // cmpq $-1, $-56(%rbp) - LONG $0x0019850f; WORD $0x0000 // jne LBB18_51, $25(%rip) +LBB13_48: + LONG $0xd07d8348; BYTE $0xff // cmpq $-1, $-48(%rbp) + LONG $0x0019850f; WORD $0x0000 // jne LBB13_50, $25(%rip) WORD $0x8948; BYTE $0xf1 // movq %rsi, %rcx - LONG $0xd04d2b48 // subq $-48(%rbp), %rcx + LONG $0xc04d2b48 // subq $-64(%rbp), %rcx LONG $0xd2bc0f49 // bsfq %r10, %rdx WORD $0x0148; BYTE $0xca // addq %rcx, %rdx - LONG $0xc04d8b48 // movq $-64(%rbp), %rcx - LONG $0xc8558948 // movq %rdx, $-56(%rbp) + LONG $0xc84d8b48 // movq $-56(%rbp), %rcx + LONG $0xd0558948 // movq %rdx, $-48(%rbp) WORD $0x8948; BYTE $0x11 // movq %rdx, (%rcx) -LBB18_51: - WORD $0x8944; BYTE $0xf1 // movl %r14d, %ecx +LBB13_50: + WORD $0x8944; BYTE $0xf9 // movl %r15d, %ecx WORD $0xd1f7 // notl %ecx WORD $0x2144; BYTE $0xd1 // andl %r10d, %ecx + LONG $0x4f0c8d45 // leal (%r15,%rcx,2), %r9d WORD $0x148d; BYTE $0x09 // leal (%rcx,%rcx), %edx - LONG $0x4e048d45 // leal (%r14,%rcx,2), %r8d WORD $0xd2f7 // notl %edx WORD $0x2144; BYTE $0xd2 // andl %r10d, %edx LONG $0xaaaae281; WORD $0xaaaa // andl $-1431655766, %edx - WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d + WORD $0x3145; BYTE $0xff // xorl %r15d, %r15d WORD $0xca01 // addl %ecx, %edx - LONG $0xc6920f41 // setb %r14b + LONG $0xc7920f41 // setb %r15b WORD $0xd201 // addl %edx, %edx LONG $0x5555f281; WORD $0x5555 // xorl $1431655765, %edx - WORD $0x2144; BYTE $0xc2 // andl %r8d, %edx + WORD $0x2144; BYTE $0xca // andl %r9d, %edx WORD $0xd2f7 // notl %edx - WORD $0xd021 // andl %edx, %eax - LONG $0xfffe92e9; BYTE $0xff // jmp LBB18_26, $-366(%rip) - -LBB18_52: - LONG $0xd0752b48 // subq $-48(%rbp), %rsi - WORD $0x0148; BYTE $0xce // addq %rcx, %rsi + WORD $0x2141; BYTE $0xd3 // andl %edx, %r11d + LONG $0xfffe9fe9; BYTE $0xff // jmp LBB13_27, $-353(%rip) -LBB18_53: - LONG $0xc0458b48 // movq $-64(%rbp), %rax - WORD $0x8948; BYTE $0x30 // movq %rsi, (%rax) +LBB13_51: + WORD $0x0148; BYTE $0xf1 // addq %rsi, %rcx + LONG $0xc8458b48 // movq $-56(%rbp), %rax + WORD $0x8948; BYTE $0x08 // movq %rcx, (%rax) LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq $-2, %rax - LONG $0xfffd8be9; BYTE $0xff // jmp LBB18_17, $-629(%rip) + LONG $0xfffd7ce9; BYTE $0xff // jmp LBB13_16, $-644(%rip) -LBB18_54: - WORD $0x854d; BYTE $0xff // testq %r15, %r15 - LONG $0x003b840f; WORD $0x0000 // je LBB18_47, $59(%rip) - LONG $0xc87d8348; BYTE $0xff // cmpq $-1, $-56(%rbp) - LONG $0x0015850f; WORD $0x0000 // jne LBB18_57, $21(%rip) - LONG $0xd04d8b48 // movq $-48(%rbp), %rcx +LBB13_52: + LONG $0xc0752b48 // subq $-64(%rbp), %rsi + WORD $0x0148; BYTE $0xce // addq %rcx, %rsi + LONG $0x00005ae9; BYTE $0x00 // jmp LBB13_58, $90(%rip) + +LBB13_53: + WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx + LONG $0x0041840f; WORD $0x0000 // je LBB13_21, $65(%rip) + WORD $0x8948; BYTE $0xda // movq %rbx, %rdx + LONG $0xd07d8348; BYTE $0xff // cmpq $-1, $-48(%rbp) + LONG $0x0015850f; WORD $0x0000 // jne LBB13_56, $21(%rip) + LONG $0xc04d8b48 // movq $-64(%rbp), %rcx WORD $0xf748; BYTE $0xd1 // notq %rcx WORD $0x0148; BYTE $0xf1 // addq %rsi, %rcx - LONG $0xc0458b48 // movq $-64(%rbp), %rax - LONG $0xc84d8948 // movq %rcx, $-56(%rbp) + LONG $0xc8458b48 // movq $-56(%rbp), %rax + LONG $0xd04d8948 // movq %rcx, $-48(%rbp) WORD $0x8948; BYTE $0x08 // movq %rcx, (%rax) -LBB18_57: +LBB13_56: WORD $0xff48; BYTE $0xc6 // incq %rsi - WORD $0xff49; BYTE $0xcf // decq %r15 + WORD $0x8948; BYTE $0xd3 // movq %rdx, %rbx + WORD $0xff48; BYTE $0xcb // decq %rbx LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax - WORD $0x854d; BYTE $0xff // testq %r15, %r15 - LONG $0xfeac850f; WORD $0xffff // jne LBB18_37, $-340(%rip) - LONG $0xfffd47e9; BYTE $0xff // jmp LBB18_17, $-697(%rip) + WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx + LONG $0xfea9850f; WORD $0xffff // jne LBB13_38, $-343(%rip) + LONG $0xfffd26e9; BYTE $0xff // jmp LBB13_16, $-730(%rip) -LBB18_47: +LBB13_21: LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax - LONG $0xfffd3be9; BYTE $0xff // jmp LBB18_17, $-709(%rip) + LONG $0xfffd1ae9; BYTE $0xff // jmp LBB13_16, $-742(%rip) -LBB18_58: - LONG $0xd0752b48 // subq $-48(%rbp), %rsi - LONG $0xffff94e9; BYTE $0xff // jmp LBB18_53, $-108(%rip) - QUAD $0x0000000000000000; LONG $0x00000000 // .p2align 4, 0x00 +LBB13_57: + LONG $0xc0752b48 // subq $-64(%rbp), %rsi -LCPI19_0: +LBB13_58: + LONG $0xc8458b48 // movq $-56(%rbp), %rax + WORD $0x8948; BYTE $0x30 // movq %rsi, (%rax) + LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq $-2, %rax + LONG $0xfffd03e9; BYTE $0xff // jmp LBB13_16, $-765(%rip) + WORD $0x0000; BYTE $0x00 // .p2align 4, 0x00 + +LCPI14_0: LONG $0x43300000 // .long 1127219200 LONG $0x45300000 // .long 1160773632 LONG $0x00000000 // .long 0 LONG $0x00000000 // .long 0 -LCPI19_1: +LCPI14_1: QUAD $0x4330000000000000 // .quad 0x4330000000000000 QUAD $0x4530000000000000 // .quad 0x4530000000000000 // .p2align 3, 0x00 -LCPI19_2: +LCPI14_2: QUAD $0x430c6bf526340000 // .quad 0x430c6bf526340000 -LCPI19_3: +LCPI14_3: QUAD $0xc30c6bf526340000 // .quad 0xc30c6bf526340000 // .p2align 4, 0x90 @@ -5026,451 +4559,480 @@ _vnumber: WORD $0x5441 // pushq %r12 BYTE $0x53 // pushq %rbx LONG $0x38ec8348 // subq $56, %rsp - WORD $0x8948; BYTE $0xd3 // movq %rdx, %rbx - WORD $0x8949; BYTE $0xf6 // movq %rsi, %r14 + WORD $0x8949; BYTE $0xd6 // movq %rdx, %r14 + QUAD $0x00000000c845c748 // movq $0, $-56(%rbp) WORD $0x8b48; BYTE $0x06 // movq (%rsi), %rax WORD $0x8b4c; BYTE $0x3f // movq (%rdi), %r15 LONG $0x086f8b4c // movq $8(%rdi), %r13 - LONG $0x20528b4c // movq $32(%rdx), %r10 + LONG $0x205a8b48 // movq $32(%rdx), %rbx LONG $0x285a8b4c // movq $40(%rdx), %r11 LONG $0x0902c748; WORD $0x0000; BYTE $0x00 // movq $9, (%rdx) - LONG $0xc0570f66 // xorpd %xmm0, %xmm0 - LONG $0x42110f66; BYTE $0x08 // movupd %xmm0, $8(%rdx) + QUAD $0x000000000842c748 // movq $0, $8(%rdx) + QUAD $0x000000001042c748 // movq $0, $16(%rdx) WORD $0x8b48; BYTE $0x0e // movq (%rsi), %rcx LONG $0x184a8948 // movq %rcx, $24(%rdx) WORD $0x394c; BYTE $0xe8 // cmpq %r13, %rax - LONG $0x02c9830f; WORD $0x0000 // jae LBB19_51, $713(%rip) - LONG $0x0cb60f41; BYTE $0x07 // movzbl (%r15,%rax), %ecx - LONG $0x000001bf; BYTE $0x00 // movl $1, %edi - WORD $0xf980; BYTE $0x2d // cmpb $45, %cl - LONG $0x0016850f; WORD $0x0000 // jne LBB19_4, $22(%rip) + LONG $0x0045830f; WORD $0x0000 // jae LBB14_6, $69(%rip) + LONG $0x073c8a41 // movb (%r15,%rax), %dil + LONG $0x0001ba41; WORD $0x0000 // movl $1, %r10d + LONG $0x2dff8040 // cmpb $45, %dil + LONG $0x0016850f; WORD $0x0000 // jne LBB14_4, $22(%rip) WORD $0xff48; BYTE $0xc0 // incq %rax WORD $0x394c; BYTE $0xe8 // cmpq %r13, %rax - LONG $0x02aa830f; WORD $0x0000 // jae LBB19_51, $682(%rip) - LONG $0x0cb60f41; BYTE $0x07 // movzbl (%r15,%rax), %ecx - LONG $0xffffffbf; BYTE $0xff // movl $-1, %edi + LONG $0x0025830f; WORD $0x0000 // jae LBB14_6, $37(%rip) + LONG $0x073c8a41 // movb (%r15,%rax), %dil + LONG $0xffffba41; WORD $0xffff // movl $-1, %r10d + +LBB14_4: + WORD $0x4f8d; BYTE $0xd0 // leal $-48(%rdi), %ecx + WORD $0xf980; BYTE $0x0a // cmpb $10, %cl + LONG $0x0028820f; WORD $0x0000 // jb LBB14_9, $40(%rip) + WORD $0x8948; BYTE $0x06 // movq %rax, (%rsi) + LONG $0xfe06c749; WORD $0xffff; BYTE $0xff // movq $-2, (%r14) + LONG $0x00000ae9; BYTE $0x00 // jmp LBB14_8, $10(%rip) -LBB19_4: - WORD $0x518d; BYTE $0xc6 // leal $-58(%rcx), %edx - WORD $0xfa80; BYTE $0xf5 // cmpb $-11, %dl - LONG $0x000f870f; WORD $0x0000 // ja LBB19_6, $15(%rip) +LBB14_6: + WORD $0x894c; BYTE $0x2e // movq %r13, (%rsi) -LBB19_5: - WORD $0x8949; BYTE $0x06 // movq %rax, (%r14) - LONG $0xfe03c748; WORD $0xffff; BYTE $0xff // movq $-2, (%rbx) - LONG $0x00028fe9; BYTE $0x00 // jmp LBB19_52, $655(%rip) +LBB14_7: + LONG $0xff06c749; WORD $0xffff; BYTE $0xff // movq $-1, (%r14) -LBB19_6: - WORD $0xf980; BYTE $0x30 // cmpb $48, %cl - LONG $0x0032850f; WORD $0x0000 // jne LBB19_10, $50(%rip) - LONG $0x01488d48 // leaq $1(%rax), %rcx +LBB14_8: + LONG $0x38c48348 // addq $56, %rsp + BYTE $0x5b // popq %rbx + WORD $0x5c41 // popq %r12 + WORD $0x5d41 // popq %r13 + WORD $0x5e41 // popq %r14 + WORD $0x5f41 // popq %r15 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB14_9: + LONG $0x30ff8040 // cmpb $48, %dil + LONG $0x0035850f; WORD $0x0000 // jne LBB14_13, $53(%rip) + LONG $0x01488d4c // leaq $1(%rax), %r9 WORD $0x394c; BYTE $0xe8 // cmpq %r13, %rax - LONG $0x00a6830f; WORD $0x0000 // jae LBB19_18, $166(%rip) - LONG $0x14b60f41; BYTE $0x0f // movzbl (%r15,%rcx), %edx - WORD $0xc283; BYTE $0xd2 // addl $-46, %edx - WORD $0xfa83; BYTE $0x37 // cmpl $55, %edx - LONG $0x0095870f; WORD $0x0000 // ja LBB19_18, $149(%rip) - QUAD $0x000000800001be48; WORD $0x0080 // movabsq $36028797027352577, %rsi - LONG $0xd6a30f48 // btq %rdx, %rsi - LONG $0x0081830f; WORD $0x0000 // jae LBB19_18, $129(%rip) - -LBB19_10: - WORD $0x7d89; BYTE $0xd4 // movl %edi, $-44(%rbp) - WORD $0x01b1 // movb $1, %cl - WORD $0x4d89; BYTE $0xc8 // movl %ecx, $-56(%rbp) - WORD $0x394c; BYTE $0xe8 // cmpq %r13, %rax - LONG $0x0063830f; WORD $0x0000 // jae LBB19_17, $99(%rip) - WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d - LONG $0xffd0b941; WORD $0xffff // movl $4294967248, %r9d - WORD $0x3145; BYTE $0xc0 // xorl %r8d, %r8d - WORD $0xc931 // xorl %ecx, %ecx - LONG $0x000012e9; BYTE $0x00 // jmp LBB19_13, $18(%rip) - LONG $0x90909090 // .p2align 4, 0x90 + LONG $0x00c8830f; WORD $0x0000 // jae LBB14_22, $200(%rip) + LONG $0x0f148a43 // movb (%r15,%r9), %dl + WORD $0xc280; BYTE $0xd2 // addb $-46, %dl + WORD $0xfa80; BYTE $0x37 // cmpb $55, %dl + LONG $0x00b8870f; WORD $0x0000 // ja LBB14_22, $184(%rip) + LONG $0xc2b60f44 // movzbl %dl, %r8d + QUAD $0x000000800001ba48; WORD $0x0080 // movabsq $36028797027352577, %rdx + LONG $0xc2a30f4c // btq %r8, %rdx + LONG $0x00a0830f; WORD $0x0000 // jae LBB14_22, $160(%rip) + +LBB14_13: + WORD $0x394c; BYTE $0xe8 // cmpq %r13, %rax + LONG $0xa05d8948 // movq %rbx, $-96(%rbp) + LONG $0xc0558944 // movl %r10d, $-64(%rbp) + LONG $0xd0758948 // movq %rsi, $-48(%rbp) + LONG $0x007e830f; WORD $0x0000 // jae LBB14_21, $126(%rip) + WORD $0xf980; BYTE $0x09 // cmpb $9, %cl + LONG $0x008a870f; WORD $0x0000 // ja LBB14_23, $138(%rip) + LONG $0xffd0b841; WORD $0xffff // movl $4294967248, %r8d + LONG $0xff4d8d4d // leaq $-1(%r13), %r9 + WORD $0xc931 // xorl %ecx, %ecx + WORD $0x3145; BYTE $0xd2 // xorl %r10d, %r10d + WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 -LBB19_12: - WORD $0xc1ff // incl %ecx - WORD $0xff48; BYTE $0xc0 // incq %rax - WORD $0x3949; BYTE $0xc5 // cmpq %rax, %r13 - LONG $0x0036840f; WORD $0x0000 // je LBB19_16, $54(%rip) +LBB14_16: + LONG $0x12fa8341 // cmpl $18, %r10d + LONG $0x00268f0f; WORD $0x0000 // jg LBB14_18, $38(%rip) + LONG $0xa4148d4b // leaq (%r12,%r12,4), %rdx + LONG $0xffbe0f40 // movsbl %dil, %edi + WORD $0x0144; BYTE $0xc7 // addl %r8d, %edi + LONG $0x57248d4c // leaq (%rdi,%rdx,2), %r12 + WORD $0xff41; BYTE $0xc2 // incl %r10d + LONG $0x000011e9; BYTE $0x00 // jmp LBB14_19, $17(%rip) + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 -LBB19_13: - LONG $0x14be0f49; BYTE $0x07 // movsbq (%r15,%rax), %rdx - WORD $0x7a8d; BYTE $0xd0 // leal $-48(%rdx), %edi - LONG $0x09ff8040 // cmpb $9, %dil - LONG $0x0041870f; WORD $0x0000 // ja LBB19_19, $65(%rip) - LONG $0x12f88341 // cmpl $18, %r8d - LONG $0xffd68f0f; WORD $0xffff // jg LBB19_12, $-42(%rip) - LONG $0xa43c8d4b // leaq (%r12,%r12,4), %rdi - WORD $0x0144; BYTE $0xca // addl %r9d, %edx - LONG $0x7a248d4c // leaq (%rdx,%rdi,2), %r12 - WORD $0xff41; BYTE $0xc0 // incl %r8d - WORD $0xff48; BYTE $0xc0 // incq %rax - WORD $0x3949; BYTE $0xc5 // cmpq %rax, %r13 - LONG $0xffca850f; WORD $0xffff // jne LBB19_13, $-54(%rip) +LBB14_18: + WORD $0xc1ff // incl %ecx -LBB19_16: - WORD $0x894c; BYTE $0xe8 // movq %r13, %rax - LONG $0x00005be9; BYTE $0x00 // jmp LBB19_24, $91(%rip) +LBB14_19: + WORD $0x3949; BYTE $0xc1 // cmpq %rax, %r9 + LONG $0x0079840f; WORD $0x0000 // je LBB14_28, $121(%rip) + LONG $0x7cb60f41; WORD $0x0107 // movzbl $1(%r15,%rax), %edi + WORD $0xff48; BYTE $0xc0 // incq %rax + WORD $0x578d; BYTE $0xd0 // leal $-48(%rdi), %edx + WORD $0xfa80; BYTE $0x0a // cmpb $10, %dl + LONG $0xffb0820f; WORD $0xffff // jb LBB14_16, $-80(%rip) + LONG $0x00001de9; BYTE $0x00 // jmp LBB14_24, $29(%rip) -LBB19_17: +LBB14_21: WORD $0xc931 // xorl %ecx, %ecx - WORD $0x3145; BYTE $0xc0 // xorl %r8d, %r8d + WORD $0x3145; BYTE $0xd2 // xorl %r10d, %r10d WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d - LONG $0x00004ee9; BYTE $0x00 // jmp LBB19_24, $78(%rip) + LONG $0x000055e9; BYTE $0x00 // jmp LBB14_29, $85(%rip) -LBB19_18: - WORD $0x8949; BYTE $0x0e // movq %rcx, (%r14) - LONG $0x0001cbe9; BYTE $0x00 // jmp LBB19_52, $459(%rip) - -LBB19_19: - WORD $0xfa80; BYTE $0x2e // cmpb $46, %dl - LONG $0x003d850f; WORD $0x0000 // jne LBB19_24, $61(%rip) - LONG $0x01508d48 // leaq $1(%rax), %rdx - LONG $0x0803c748; WORD $0x0000; BYTE $0x00 // movq $8, (%rbx) - WORD $0x394c; BYTE $0xea // cmpq %r13, %rdx - LONG $0x01a4830f; WORD $0x0000 // jae LBB19_51, $420(%rip) - LONG $0x44b60f41; WORD $0x0107 // movzbl $1(%r15,%rax), %eax - WORD $0xc604 // addb $-58, %al - WORD $0xf53c // cmpb $-11, %al - LONG $0x000f870f; WORD $0x0000 // ja LBB19_23, $15(%rip) - WORD $0x8949; BYTE $0x16 // movq %rdx, (%r14) - LONG $0xfe03c748; WORD $0xffff; BYTE $0xff // movq $-2, (%rbx) - LONG $0x00018fe9; BYTE $0x00 // jmp LBB19_52, $399(%rip) - -LBB19_23: - LONG $0x00c845c7; WORD $0x0000; BYTE $0x00 // movl $0, $-56(%rbp) - WORD $0x8948; BYTE $0xd0 // movq %rdx, %rax +LBB14_22: + WORD $0x894c; BYTE $0x0e // movq %r9, (%rsi) + LONG $0xffff0ae9; BYTE $0xff // jmp LBB14_8, $-246(%rip) -LBB19_24: - WORD $0xd231 // xorl %edx, %edx - WORD $0xc985 // testl %ecx, %ecx - WORD $0x9f0f; BYTE $0xc2 // setg %dl - WORD $0x5589; BYTE $0xbc // movl %edx, $-68(%rbp) - WORD $0x854d; BYTE $0xe4 // testq %r12, %r12 - LONG $0x005d850f; WORD $0x0000 // jne LBB19_33, $93(%rip) - WORD $0xc985 // testl %ecx, %ecx - LONG $0x0055850f; WORD $0x0000 // jne LBB19_33, $85(%rip) - WORD $0x394c; BYTE $0xe8 // cmpq %r13, %rax - LONG $0x0044830f; WORD $0x0000 // jae LBB19_31, $68(%rip) - WORD $0xc689 // movl %eax, %esi - WORD $0x2944; BYTE $0xee // subl %r13d, %esi - WORD $0x3145; BYTE $0xc0 // xorl %r8d, %r8d - WORD $0xc931 // xorl %ecx, %ecx - QUAD $0x9090909090909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 +LBB14_23: + WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d + WORD $0x3145; BYTE $0xd2 // xorl %r10d, %r10d + WORD $0xc931 // xorl %ecx, %ecx + +LBB14_24: + WORD $0xd231 // xorl %edx, %edx + WORD $0xc985 // testl %ecx, %ecx + WORD $0x9f0f; BYTE $0xc2 // setg %dl + WORD $0x5589; BYTE $0xc4 // movl %edx, $-60(%rbp) + WORD $0xb041; BYTE $0x01 // movb $1, %r8b + LONG $0x2eff8040 // cmpb $46, %dil + LONG $0x003b850f; WORD $0x0000 // jne LBB14_30, $59(%rip) + WORD $0xff48; BYTE $0xc0 // incq %rax + LONG $0x0806c749; WORD $0x0000; BYTE $0x00 // movq $8, (%r14) + WORD $0x394c; BYTE $0xe8 // cmpq %r13, %rax + LONG $0x026a830f; WORD $0x0000 // jae LBB14_68, $618(%rip) + LONG $0x07148a41 // movb (%r15,%rax), %dl + WORD $0xc280; BYTE $0xd0 // addb $-48, %dl + WORD $0xfa80; BYTE $0x0a // cmpb $10, %dl + LONG $0x0405830f; WORD $0x0000 // jae LBB14_91, $1029(%rip) + WORD $0x3145; BYTE $0xc0 // xorl %r8d, %r8d + LONG $0x000010e9; BYTE $0x00 // jmp LBB14_30, $16(%rip) + +LBB14_28: + WORD $0x894c; BYTE $0xe8 // movq %r13, %rax -LBB19_28: +LBB14_29: + WORD $0xd231 // xorl %edx, %edx + WORD $0xc985 // testl %ecx, %ecx + WORD $0x9f0f; BYTE $0xc2 // setg %dl + WORD $0x5589; BYTE $0xc4 // movl %edx, $-60(%rbp) + WORD $0xb041; BYTE $0x01 // movb $1, %r8b + +LBB14_30: + WORD $0xc985 // testl %ecx, %ecx + LONG $0x0056850f; WORD $0x0000 // jne LBB14_39, $86(%rip) + WORD $0x854d; BYTE $0xe4 // testq %r12, %r12 + LONG $0x004d850f; WORD $0x0000 // jne LBB14_39, $77(%rip) + WORD $0x394c; BYTE $0xe8 // cmpq %r13, %rax + LONG $0x003c830f; WORD $0x0000 // jae LBB14_37, $60(%rip) + WORD $0xc689 // movl %eax, %esi + WORD $0x2944; BYTE $0xee // subl %r13d, %esi + WORD $0x3145; BYTE $0xd2 // xorl %r10d, %r10d + WORD $0xc931 // xorl %ecx, %ecx + QUAD $0x9090909090909090 // .p2align 4, 0x90 + +LBB14_34: LONG $0x073c8041; BYTE $0x30 // cmpb $48, (%r15,%rax) - LONG $0x0029850f; WORD $0x0000 // jne LBB19_32, $41(%rip) + LONG $0x0024850f; WORD $0x0000 // jne LBB14_38, $36(%rip) WORD $0xff48; BYTE $0xc0 // incq %rax WORD $0xc9ff // decl %ecx WORD $0x3949; BYTE $0xc5 // cmpq %rax, %r13 - LONG $0xffe7850f; WORD $0xffff // jne LBB19_28, $-25(%rip) + LONG $0xffe7850f; WORD $0xffff // jne LBB14_34, $-25(%rip) WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d - WORD $0x458b; BYTE $0xc8 // movl $-56(%rbp), %eax - WORD $0xc084 // testb %al, %al - LONG $0x0144850f; WORD $0x0000 // jne LBB19_54, $324(%rip) + WORD $0x8445; BYTE $0xc0 // testb %r8b, %r8b + LONG $0x0122850f; WORD $0x0000 // jne LBB14_58, $290(%rip) + LONG $0x000152e9; BYTE $0x00 // jmp LBB14_62, $338(%rip) -LBB19_59: - WORD $0x558b; BYTE $0xd4 // movl $-44(%rbp), %edx - LONG $0x000173e9; BYTE $0x00 // jmp LBB19_60, $371(%rip) - -LBB19_31: +LBB14_37: WORD $0xc931 // xorl %ecx, %ecx - WORD $0x3145; BYTE $0xc0 // xorl %r8d, %r8d + WORD $0x3145; BYTE $0xd2 // xorl %r10d, %r10d -LBB19_32: +LBB14_38: WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d -LBB19_33: +LBB14_39: WORD $0x394c; BYTE $0xe8 // cmpq %r13, %rax - LONG $0x004c830f; WORD $0x0000 // jae LBB19_39, $76(%rip) - LONG $0x12f88341 // cmpl $18, %r8d - LONG $0x00428f0f; WORD $0x0000 // jg LBB19_39, $66(%rip) + LONG $0x0051830f; WORD $0x0000 // jae LBB14_45, $81(%rip) + LONG $0x12fa8341 // cmpl $18, %r10d + LONG $0x00478f0f; WORD $0x0000 // jg LBB14_45, $71(%rip) LONG $0xffd0b941; WORD $0xffff // movl $4294967248, %r9d + LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 - // .p2align 4, 0x90 -LBB19_36: +LBB14_42: LONG $0x14b60f41; BYTE $0x07 // movzbl (%r15,%rax), %edx WORD $0x7a8d; BYTE $0xd0 // leal $-48(%rdx), %edi LONG $0x09ff8040 // cmpb $9, %dil - LONG $0x002a870f; WORD $0x0000 // ja LBB19_39, $42(%rip) + LONG $0x002a870f; WORD $0x0000 // ja LBB14_45, $42(%rip) LONG $0xa43c8d4b // leaq (%r12,%r12,4), %rdi WORD $0x0144; BYTE $0xca // addl %r9d, %edx LONG $0x7a248d4c // leaq (%rdx,%rdi,2), %r12 WORD $0xc9ff // decl %ecx WORD $0xff48; BYTE $0xc0 // incq %rax WORD $0x394c; BYTE $0xe8 // cmpq %r13, %rax - LONG $0x0011830f; WORD $0x0000 // jae LBB19_39, $17(%rip) - LONG $0x01508d41 // leal $1(%r8), %edx - LONG $0x12f88341 // cmpl $18, %r8d - WORD $0x8941; BYTE $0xd0 // movl %edx, %r8d - LONG $0xffc48c0f; WORD $0xffff // jl LBB19_36, $-60(%rip) + LONG $0x0011830f; WORD $0x0000 // jae LBB14_45, $17(%rip) + LONG $0x01528d41 // leal $1(%r10), %edx + LONG $0x12fa8341 // cmpl $18, %r10d + WORD $0x8941; BYTE $0xd2 // movl %edx, %r10d + LONG $0xffc48c0f; WORD $0xffff // jl LBB14_42, $-60(%rip) -LBB19_39: - WORD $0x394c; BYTE $0xe8 // cmpq %r13, %rax - LONG $0x00c6830f; WORD $0x0000 // jae LBB19_53, $198(%rip) - LONG $0x34b60f41; BYTE $0x07 // movzbl (%r15,%rax), %esi - WORD $0x568d; BYTE $0xd0 // leal $-48(%rsi), %edx - WORD $0xfa80; BYTE $0x09 // cmpb $9, %dl - LONG $0x0030870f; WORD $0x0000 // ja LBB19_45, $48(%rip) - LONG $0xff558d49 // leaq $-1(%r13), %rdx - LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 +LBB14_45: + WORD $0x394c; BYTE $0xe8 // cmpq %r13, %rax + LONG $0x00a4830f; WORD $0x0000 // jae LBB14_57, $164(%rip) + LONG $0x07348a41 // movb (%r15,%rax), %sil + WORD $0x568d; BYTE $0xd0 // leal $-48(%rsi), %edx + WORD $0xfa80; BYTE $0x09 // cmpb $9, %dl + LONG $0x0030870f; WORD $0x0000 // ja LBB14_51, $48(%rip) + LONG $0xff7d8d49 // leaq $-1(%r13), %rdi + LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 -LBB19_42: - WORD $0x3948; BYTE $0xc2 // cmpq %rax, %rdx - LONG $0x0182840f; WORD $0x0000 // je LBB19_58, $386(%rip) +LBB14_48: + WORD $0x3948; BYTE $0xc7 // cmpq %rax, %rdi + LONG $0x0169840f; WORD $0x0000 // je LBB14_69, $361(%rip) LONG $0x74b60f41; WORD $0x0107 // movzbl $1(%r15,%rax), %esi - WORD $0x7e8d; BYTE $0xd0 // leal $-48(%rsi), %edi WORD $0xff48; BYTE $0xc0 // incq %rax - LONG $0x09ff8040 // cmpb $9, %dil - LONG $0xffe1860f; WORD $0xffff // jbe LBB19_42, $-31(%rip) - LONG $0x01bc45c7; WORD $0x0000; BYTE $0x00 // movl $1, $-68(%rbp) - -LBB19_45: - LONG $0xd6b60f40 // movzbl %sil, %edx - WORD $0xca83; BYTE $0x20 // orl $32, %edx - WORD $0xfa83; BYTE $0x65 // cmpl $101, %edx - LONG $0x0075850f; WORD $0x0000 // jne LBB19_53, $117(%rip) + WORD $0x568d; BYTE $0xd0 // leal $-48(%rsi), %edx + WORD $0xfa80; BYTE $0x09 // cmpb $9, %dl + LONG $0xffe2860f; WORD $0xffff // jbe LBB14_48, $-30(%rip) + LONG $0x01c445c7; WORD $0x0000; BYTE $0x00 // movl $1, $-60(%rbp) + +LBB14_51: + LONG $0x20ce8040 // orb $32, %sil + LONG $0x65fe8040 // cmpb $101, %sil + LONG $0x0056850f; WORD $0x0000 // jne LBB14_57, $86(%rip) LONG $0x01788d48 // leaq $1(%rax), %rdi - LONG $0x0803c748; WORD $0x0000; BYTE $0x00 // movq $8, (%rbx) + LONG $0x0806c749; WORD $0x0000; BYTE $0x00 // movq $8, (%r14) WORD $0x394c; BYTE $0xef // cmpq %r13, %rdi - LONG $0x0048830f; WORD $0x0000 // jae LBB19_51, $72(%rip) - LONG $0x34b60f41; BYTE $0x3f // movzbl (%r15,%rdi), %esi - WORD $0xfe83; BYTE $0x2d // cmpl $45, %esi - LONG $0x000f840f; WORD $0x0000 // je LBB19_49, $15(%rip) + LONG $0x011f830f; WORD $0x0000 // jae LBB14_68, $287(%rip) + LONG $0x3f348a41 // movb (%r15,%rdi), %sil + LONG $0x2dfe8040 // cmpb $45, %sil + LONG $0x0010840f; WORD $0x0000 // je LBB14_55, $16(%rip) LONG $0x0001b841; WORD $0x0000 // movl $1, %r8d - WORD $0xfe83; BYTE $0x2b // cmpl $43, %esi - LONG $0x02ac850f; WORD $0x0000 // jne LBB19_86, $684(%rip) + LONG $0x2bfe8040 // cmpb $43, %sil + LONG $0x029c850f; WORD $0x0000 // jne LBB14_89, $668(%rip) -LBB19_49: +LBB14_55: LONG $0x02c08348 // addq $2, %rax WORD $0x394c; BYTE $0xe8 // cmpq %r13, %rax - WORD $0x558b; BYTE $0xd4 // movl $-44(%rbp), %edx - LONG $0x001b830f; WORD $0x0000 // jae LBB19_51, $27(%rip) - WORD $0xff31 // xorl %edi, %edi + LONG $0x00f4830f; WORD $0x0000 // jae LBB14_68, $244(%rip) + WORD $0xd231 // xorl %edx, %edx LONG $0x2bfe8040 // cmpb $43, %sil - LONG $0xc7940f40 // sete %dil - LONG $0x3f048d44 // leal (%rdi,%rdi), %r8d - WORD $0xff41; BYTE $0xc8 // decl %r8d - LONG $0x34b60f41; BYTE $0x07 // movzbl (%r15,%rax), %esi - LONG $0x000287e9; BYTE $0x00 // jmp LBB19_87, $647(%rip) + WORD $0x940f; BYTE $0xc2 // sete %dl + LONG $0x12448d44; BYTE $0xff // leal $-1(%rdx,%rdx), %r8d + LONG $0x07348a41 // movb (%r15,%rax), %sil + LONG $0x00027be9; BYTE $0x00 // jmp LBB14_90, $635(%rip) -LBB19_51: - WORD $0x894d; BYTE $0x2e // movq %r13, (%r14) - LONG $0xff03c748; WORD $0xffff; BYTE $0xff // movq $-1, (%rbx) - -LBB19_52: - LONG $0x38c48348 // addq $56, %rsp - BYTE $0x5b // popq %rbx - WORD $0x5c41 // popq %r12 - WORD $0x5d41 // popq %r13 - WORD $0x5e41 // popq %r14 - WORD $0x5f41 // popq %r15 - BYTE $0x5d // popq %rbp - BYTE $0xc3 // retq - -LBB19_53: +LBB14_57: WORD $0xce89 // movl %ecx, %esi WORD $0x8949; BYTE $0xc5 // movq %rax, %r13 - WORD $0x458b; BYTE $0xc8 // movl $-56(%rbp), %eax - WORD $0xc084 // testb %al, %al - LONG $0xfebc840f; WORD $0xffff // je LBB19_59, $-324(%rip) + WORD $0x8445; BYTE $0xc0 // testb %r8b, %r8b + LONG $0x0035840f; WORD $0x0000 // je LBB14_62, $53(%rip) -LBB19_54: +LBB14_58: WORD $0xf685 // testl %esi, %esi - WORD $0x558b; BYTE $0xd4 // movl $-44(%rbp), %edx - LONG $0x0025850f; WORD $0x0000 // jne LBB19_57, $37(%rip) + LONG $0x0026850f; WORD $0x0000 // jne LBB14_61, $38(%rip) QUAD $0x000000000000b848; WORD $0x8000 // movabsq $-9223372036854775808, %rax - WORD $0x6348; BYTE $0xca // movslq %edx, %rcx + LONG $0xc04d6348 // movslq $-64(%rbp), %rcx WORD $0x854d; BYTE $0xe4 // testq %r12, %r12 - LONG $0x00e9890f; WORD $0x0000 // jns LBB19_68, $233(%rip) - WORD $0x894c; BYTE $0xe7 // movq %r12, %rdi - WORD $0x2148; BYTE $0xcf // andq %rcx, %rdi - WORD $0x3948; BYTE $0xc7 // cmpq %rax, %rdi - LONG $0x00da840f; WORD $0x0000 // je LBB19_68, $218(%rip) + LONG $0x00f4890f; WORD $0x0000 // jns LBB14_72, $244(%rip) + WORD $0x894c; BYTE $0xe2 // movq %r12, %rdx + WORD $0x2148; BYTE $0xca // andq %rcx, %rdx + WORD $0x3948; BYTE $0xc2 // cmpq %rax, %rdx + LONG $0x00e5840f; WORD $0x0000 // je LBB14_72, $229(%rip) -LBB19_57: - LONG $0x0803c748; WORD $0x0000; BYTE $0x00 // movq $8, (%rbx) +LBB14_61: + LONG $0x0806c749; WORD $0x0000; BYTE $0x00 // movq $8, (%r14) -LBB19_60: - QUAD $0x00000000b045c748 // movq $0, $-80(%rbp) +LBB14_62: + QUAD $0x00000000b845c748 // movq $0, $-72(%rbp) LONG $0x6e0f4966; BYTE $0xcc // movq %r12, %xmm1 - QUAD $0xfffffc490d620f66 // punpckldq $-951(%rip), %xmm1 /* LCPI19_0(%rip) */ - QUAD $0xfffffc510d5c0f66 // subpd $-943(%rip), %xmm1 /* LCPI19_1(%rip) */ + QUAD $0xfffffc1f0d620f66 // punpckldq $-993(%rip), %xmm1 /* LCPI14_0(%rip) */ + QUAD $0xfffffc270d5c0f66 // subpd $-985(%rip), %xmm1 /* LCPI14_1(%rip) */ LONG $0xc1280f66 // movapd %xmm1, %xmm0 LONG $0xc1150f66 // unpckhpd %xmm1, %xmm0 LONG $0xc1580ff2 // addsd %xmm1, %xmm0 - LONG $0x45110ff2; BYTE $0xc0 // movsd %xmm0, $-64(%rbp) + LONG $0x45110ff2; BYTE $0xc8 // movsd %xmm0, $-56(%rbp) WORD $0x894c; BYTE $0xe0 // movq %r12, %rax LONG $0x34e8c148 // shrq $52, %rax - LONG $0x010f850f; WORD $0x0000 // jne LBB19_73, $271(%rip) + LONG $0x0121850f; WORD $0x0000 // jne LBB14_77, $289(%rip) LONG $0x7e0f4866; BYTE $0xc1 // movq %xmm0, %rcx - WORD $0xd089 // movl %edx, %eax + WORD $0x458b; BYTE $0xc0 // movl $-64(%rbp), %eax WORD $0xe8c1; BYTE $0x1f // shrl $31, %eax LONG $0x3fe0c148 // shlq $63, %rax WORD $0x0948; BYTE $0xc8 // orq %rcx, %rax - LONG $0xc0458948 // movq %rax, $-64(%rbp) + LONG $0xc8458948 // movq %rax, $-56(%rbp) WORD $0x854d; BYTE $0xe4 // testq %r12, %r12 - LONG $0x018c840f; WORD $0x0000 // je LBB19_81, $396(%rip) + LONG $0x01a1840f; WORD $0x0000 // je LBB14_85, $417(%rip) WORD $0xf685 // testl %esi, %esi - LONG $0x0184840f; WORD $0x0000 // je LBB19_81, $388(%rip) + LONG $0x0199840f; WORD $0x0000 // je LBB14_85, $409(%rip) LONG $0x6e0f4866; BYTE $0xc0 // movq %rax, %xmm0 WORD $0x468d; BYTE $0xff // leal $-1(%rsi), %eax WORD $0xf883; BYTE $0x24 // cmpl $36, %eax - LONG $0x0040870f; WORD $0x0000 // ja LBB19_66, $64(%rip) + LONG $0x004a870f; WORD $0x0000 // ja LBB14_70, $74(%rip) WORD $0xfe83; BYTE $0x17 // cmpl $23, %esi - LONG $0x0095820f; WORD $0x0000 // jb LBB19_69, $149(%rip) + LONG $0x00a68c0f; WORD $0x0000 // jl LBB14_73, $166(%rip) WORD $0x468d; BYTE $0xea // leal $-22(%rsi), %eax - LONG $0x790d8d48; WORD $0x00e1; BYTE $0x00 // leaq $57721(%rip), %rcx /* _P10_TAB(%rip) */ + LONG $0xfe0d8d48; WORD $0x00ee; BYTE $0x00 // leaq $61182(%rip), %rcx /* _P10_TAB(%rip) */ LONG $0x04590ff2; BYTE $0xc1 // mulsd (%rcx,%rax,8), %xmm0 - LONG $0x45110ff2; BYTE $0xc0 // movsd %xmm0, $-64(%rbp) + LONG $0x45110ff2; BYTE $0xc8 // movsd %xmm0, $-56(%rbp) LONG $0x000016b8; BYTE $0x00 // movl $22, %eax - LONG $0x000079e9; BYTE $0x00 // jmp LBB19_70, $121(%rip) + LONG $0x00008ae9; BYTE $0x00 // jmp LBB14_74, $138(%rip) + +LBB14_68: + LONG $0xd0458b48 // movq $-48(%rbp), %rax + WORD $0x894c; BYTE $0x28 // movq %r13, (%rax) + LONG $0xfffc5be9; BYTE $0xff // jmp LBB14_7, $-933(%rip) -LBB19_58: - LONG $0x01bc45c7; WORD $0x0000; BYTE $0x00 // movl $1, $-68(%rbp) +LBB14_69: + LONG $0x01c445c7; WORD $0x0000; BYTE $0x00 // movl $1, $-60(%rbp) WORD $0xce89 // movl %ecx, %esi - WORD $0x458b; BYTE $0xc8 // movl $-56(%rbp), %eax - WORD $0xc084 // testb %al, %al - LONG $0xff1c850f; WORD $0xffff // jne LBB19_54, $-228(%rip) - LONG $0xfffdd3e9; BYTE $0xff // jmp LBB19_59, $-557(%rip) + WORD $0x8445; BYTE $0xc0 // testb %r8b, %r8b + LONG $0xff13850f; WORD $0xffff // jne LBB14_58, $-237(%rip) + LONG $0xffff43e9; BYTE $0xff // jmp LBB14_62, $-189(%rip) -LBB19_66: +LBB14_70: WORD $0xfe83; BYTE $0xea // cmpl $-22, %esi - LONG $0x008f820f; WORD $0x0000 // jb LBB19_73, $143(%rip) + LONG $0x0096820f; WORD $0x0000 // jb LBB14_77, $150(%rip) WORD $0xdef7 // negl %esi - LONG $0x3a058d48; WORD $0x00e1; BYTE $0x00 // leaq $57658(%rip), %rax /* _P10_TAB(%rip) */ + LONG $0xb5058d48; WORD $0x00ee; BYTE $0x00 // leaq $61109(%rip), %rax /* _P10_TAB(%rip) */ LONG $0x045e0ff2; BYTE $0xf0 // divsd (%rax,%rsi,8), %xmm0 - LONG $0x45110ff2; BYTE $0xc0 // movsd %xmm0, $-64(%rbp) - LONG $0x0000d9e9; BYTE $0x00 // jmp LBB19_77, $217(%rip) + LONG $0x45110ff2; BYTE $0xc8 // movsd %xmm0, $-56(%rbp) + LONG $0x0000e0e9; BYTE $0x00 // jmp LBB14_81, $224(%rip) -LBB19_68: +LBB14_72: LONG $0x6e0f4966; BYTE $0xc4 // movq %r12, %xmm0 LONG $0xe1af0f4c // imulq %rcx, %r12 - LONG $0x1063894c // movq %r12, $16(%rbx) - QUAD $0xfffffb7605620f66 // punpckldq $-1162(%rip), %xmm0 /* LCPI19_0(%rip) */ - QUAD $0xfffffb7e055c0f66 // subpd $-1154(%rip), %xmm0 /* LCPI19_1(%rip) */ + QUAD $0xfffffb4505620f66 // punpckldq $-1211(%rip), %xmm0 /* LCPI14_0(%rip) */ + QUAD $0xfffffb4d055c0f66 // subpd $-1203(%rip), %xmm0 /* LCPI14_1(%rip) */ + LONG $0x1066894d // movq %r12, $16(%r14) LONG $0xc8280f66 // movapd %xmm0, %xmm1 LONG $0xc8150f66 // unpckhpd %xmm0, %xmm1 LONG $0xc8580ff2 // addsd %xmm0, %xmm1 WORD $0x2148; BYTE $0xc8 // andq %rcx, %rax LONG $0x7e0f4866; BYTE $0xc9 // movq %xmm1, %rcx WORD $0x0948; BYTE $0xc1 // orq %rax, %rcx - LONG $0x084b8948 // movq %rcx, $8(%rbx) - LONG $0x000109e9; BYTE $0x00 // jmp LBB19_85, $265(%rip) + LONG $0x084e8949 // movq %rcx, $8(%r14) + LONG $0xd0458b48 // movq $-48(%rbp), %rax + WORD $0x894c; BYTE $0x28 // movq %r13, (%rax) + LONG $0xfffbe6e9; BYTE $0xff // jmp LBB14_8, $-1050(%rip) -LBB19_69: +LBB14_73: WORD $0xf089 // movl %esi, %eax -LBB19_70: - QUAD $0xfffffb64052e0f66 // ucomisd $-1180(%rip), %xmm0 /* LCPI19_2(%rip) */ - LONG $0x002a870f; WORD $0x0000 // ja LBB19_73, $42(%rip) - QUAD $0xfffffb5e0d100ff2 // movsd $-1186(%rip), %xmm1 /* LCPI19_3(%rip) */ +LBB14_74: + QUAD $0xfffffb28052e0f66 // ucomisd $-1240(%rip), %xmm0 /* LCPI14_2(%rip) */ + LONG $0x002a870f; WORD $0x0000 // ja LBB14_77, $42(%rip) + QUAD $0xfffffb220d100ff2 // movsd $-1246(%rip), %xmm1 /* LCPI14_3(%rip) */ LONG $0xc82e0f66 // ucomisd %xmm0, %xmm1 - LONG $0x0018870f; WORD $0x0000 // ja LBB19_73, $24(%rip) + LONG $0x0018870f; WORD $0x0000 // ja LBB14_77, $24(%rip) WORD $0xc089 // movl %eax, %eax - LONG $0xc30d8d48; WORD $0x00e0; BYTE $0x00 // leaq $57539(%rip), %rcx /* _P10_TAB(%rip) */ + LONG $0x370d8d48; WORD $0x00ee; BYTE $0x00 // leaq $60983(%rip), %rcx /* _P10_TAB(%rip) */ LONG $0x04590ff2; BYTE $0xc1 // mulsd (%rcx,%rax,8), %xmm0 - LONG $0x45110ff2; BYTE $0xc0 // movsd %xmm0, $-64(%rbp) - LONG $0x000062e9; BYTE $0x00 // jmp LBB19_77, $98(%rip) + LONG $0x45110ff2; BYTE $0xc8 // movsd %xmm0, $-56(%rbp) + LONG $0x000062e9; BYTE $0x00 // jmp LBB14_81, $98(%rip) -LBB19_73: - LONG $0xa05d894c // movq %r11, $-96(%rbp) - LONG $0xc855894c // movq %r10, $-56(%rbp) - LONG $0xc04d8d48 // leaq $-64(%rbp), %rcx +LBB14_77: + LONG $0xa85d894c // movq %r11, $-88(%rbp) + LONG $0xc84d8d48 // leaq $-56(%rbp), %rcx WORD $0x894c; BYTE $0xe7 // movq %r12, %rdi - LONG $0xa8758948 // movq %rsi, $-88(%rbp) - LONG $0xffe38ce8; BYTE $0xff // callq _atof_eisel_lemire64, $-7284(%rip) + WORD $0x5d8b; BYTE $0xc0 // movl $-64(%rbp), %ebx + WORD $0xda89 // movl %ebx, %edx + LONG $0xb0758948 // movq %rsi, $-80(%rbp) + LONG $0xffe5bfe8; BYTE $0xff // callq _atof_eisel_lemire64, $-6721(%rip) WORD $0xc084 // testb %al, %al - LONG $0x004c840f; WORD $0x0000 // je LBB19_79, $76(%rip) - LONG $0x00bc7d83 // cmpl $0, $-68(%rbp) - LONG $0x006d840f; WORD $0x0000 // je LBB19_80, $109(%rip) + LONG $0x004b840f; WORD $0x0000 // je LBB14_83, $75(%rip) + LONG $0xb0758b48 // movq $-80(%rbp), %rsi + LONG $0x00c47d83 // cmpl $0, $-60(%rbp) + LONG $0x006c840f; WORD $0x0000 // je LBB14_84, $108(%rip) WORD $0xff49; BYTE $0xc4 // incq %r12 - LONG $0xb04d8d48 // leaq $-80(%rbp), %rcx + LONG $0xb84d8d48 // leaq $-72(%rbp), %rcx WORD $0x894c; BYTE $0xe7 // movq %r12, %rdi - LONG $0xa8758b48 // movq $-88(%rbp), %rsi - WORD $0x558b; BYTE $0xd4 // movl $-44(%rbp), %edx - LONG $0xffe364e8; BYTE $0xff // callq _atof_eisel_lemire64, $-7324(%rip) + WORD $0xda89 // movl %ebx, %edx + LONG $0xffe598e8; BYTE $0xff // callq _atof_eisel_lemire64, $-6760(%rip) WORD $0xc084 // testb %al, %al - LONG $0x0024840f; WORD $0x0000 // je LBB19_79, $36(%rip) - LONG $0x4d100ff2; BYTE $0xb0 // movsd $-80(%rbp), %xmm1 - LONG $0x45100ff2; BYTE $0xc0 // movsd $-64(%rbp), %xmm0 + LONG $0x0024840f; WORD $0x0000 // je LBB14_83, $36(%rip) + LONG $0x4d100ff2; BYTE $0xb8 // movsd $-72(%rbp), %xmm1 + LONG $0x45100ff2; BYTE $0xc8 // movsd $-56(%rbp), %xmm0 LONG $0xc82e0f66 // ucomisd %xmm0, %xmm1 - LONG $0x0010850f; WORD $0x0000 // jne LBB19_79, $16(%rip) - LONG $0x000a8a0f; WORD $0x0000 // jp LBB19_79, $10(%rip) + LONG $0x0010850f; WORD $0x0000 // jne LBB14_83, $16(%rip) + LONG $0x000a8a0f; WORD $0x0000 // jp LBB14_83, $10(%rip) -LBB19_77: +LBB14_81: LONG $0x7e0f4866; BYTE $0xc0 // movq %xmm0, %rax - LONG $0x00002fe9; BYTE $0x00 // jmp LBB19_81, $47(%rip) + LONG $0x000033e9; BYTE $0x00 // jmp LBB14_85, $51(%rip) -LBB19_79: - WORD $0x8b49; BYTE $0x06 // movq (%r14), %rax +LBB14_83: + LONG $0xd05d8b48 // movq $-48(%rbp), %rbx + WORD $0x8b48; BYTE $0x03 // movq (%rbx), %rax WORD $0x0149; BYTE $0xc7 // addq %rax, %r15 WORD $0x894c; BYTE $0xee // movq %r13, %rsi WORD $0x2948; BYTE $0xc6 // subq %rax, %rsi WORD $0x894c; BYTE $0xff // movq %r15, %rdi - LONG $0xc8558b48 // movq $-56(%rbp), %rdx - LONG $0xa04d8b48 // movq $-96(%rbp), %rcx - LONG $0xffe8cce8; BYTE $0xff // callq _atof_native, $-5940(%rip) - LONG $0x45110ff2; BYTE $0xc0 // movsd %xmm0, $-64(%rbp) + LONG $0xa0558b48 // movq $-96(%rbp), %rdx + LONG $0xa84d8b48 // movq $-88(%rbp), %rcx + LONG $0xffea9ce8; BYTE $0xff // callq _atof_native, $-5476(%rip) + LONG $0x45110ff2; BYTE $0xc8 // movsd %xmm0, $-56(%rbp) LONG $0x7e0f4866; BYTE $0xc0 // movq %xmm0, %rax - LONG $0x000009e9; BYTE $0x00 // jmp LBB19_82, $9(%rip) + LONG $0x000008e9; BYTE $0x00 // jmp LBB14_86, $8(%rip) -LBB19_80: - LONG $0xc0458b48 // movq $-64(%rbp), %rax +LBB14_84: + LONG $0xc8458b48 // movq $-56(%rbp), %rax -LBB19_81: - LONG $0x6e0f4866; BYTE $0xc0 // movq %rax, %xmm0 +LBB14_85: + LONG $0xd05d8b48 // movq $-48(%rbp), %rbx -LBB19_82: +LBB14_86: QUAD $0x000000000000b948; WORD $0x8000 // movabsq $-9223372036854775808, %rcx WORD $0xff48; BYTE $0xc9 // decq %rcx WORD $0x2148; BYTE $0xc1 // andq %rax, %rcx - QUAD $0x000000000000b848; WORD $0x7ff0 // movabsq $9218868437227405312, %rax - WORD $0x3948; BYTE $0xc1 // cmpq %rax, %rcx - LONG $0x0007850f; WORD $0x0000 // jne LBB19_84, $7(%rip) - LONG $0xf803c748; WORD $0xffff; BYTE $0xff // movq $-8, (%rbx) - -LBB19_84: - LONG $0x43110ff2; BYTE $0x08 // movsd %xmm0, $8(%rbx) + QUAD $0x000000000000ba48; WORD $0x7ff0 // movabsq $9218868437227405312, %rdx + WORD $0x3948; BYTE $0xd1 // cmpq %rdx, %rcx + LONG $0x0007850f; WORD $0x0000 // jne LBB14_88, $7(%rip) + LONG $0xf806c749; WORD $0xffff; BYTE $0xff // movq $-8, (%r14) -LBB19_85: - WORD $0x894d; BYTE $0x2e // movq %r13, (%r14) - LONG $0xfffd89e9; BYTE $0xff // jmp LBB19_52, $-631(%rip) +LBB14_88: + LONG $0x08468949 // movq %rax, $8(%r14) + WORD $0x894c; BYTE $0x2b // movq %r13, (%rbx) + LONG $0xfffad3e9; BYTE $0xff // jmp LBB14_8, $-1325(%rip) -LBB19_86: +LBB14_89: WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax - WORD $0x558b; BYTE $0xd4 // movl $-44(%rbp), %edx -LBB19_87: - LONG $0xc6c68040 // addb $-58, %sil - LONG $0xf6fe8040 // cmpb $-10, %sil - LONG $0xfad7820f; WORD $0xffff // jb LBB19_5, $-1321(%rip) - WORD $0xf631 // xorl %esi, %esi - WORD $0x394c; BYTE $0xe8 // cmpq %r13, %rax - LONG $0x0035830f; WORD $0x0000 // jae LBB19_93, $53(%rip) - WORD $0xf631 // xorl %esi, %esi +LBB14_90: + WORD $0x7e8d; BYTE $0xd0 // leal $-48(%rsi), %edi + LONG $0x09ff8040 // cmpb $9, %dil + LONG $0x0013860f; WORD $0x0000 // jbe LBB14_92, $19(%rip) + +LBB14_91: + LONG $0xd04d8b48 // movq $-48(%rbp), %rcx + WORD $0x8948; BYTE $0x01 // movq %rax, (%rcx) + LONG $0xfe06c749; WORD $0xffff; BYTE $0xff // movq $-2, (%r14) + LONG $0xfffab0e9; BYTE $0xff // jmp LBB14_8, $-1360(%rip) -LBB19_90: - LONG $0x0cb60f45; BYTE $0x07 // movzbl (%r15,%rax), %r9d - LONG $0xd0798d41 // leal $-48(%r9), %edi +LBB14_92: + WORD $0x394c; BYTE $0xe8 // cmpq %r13, %rax + LONG $0x0049830f; WORD $0x0000 // jae LBB14_98, $73(%rip) LONG $0x09ff8040 // cmpb $9, %dil - LONG $0x0020870f; WORD $0x0000 // ja LBB19_93, $32(%rip) - LONG $0x2710fe81; WORD $0x0000 // cmpl $10000, %esi - WORD $0x3c8d; BYTE $0xb6 // leal (%rsi,%rsi,4), %edi - LONG $0x797c8d41; BYTE $0xd0 // leal $-48(%r9,%rdi,2), %edi - WORD $0x4c0f; BYTE $0xf7 // cmovll %edi, %esi + LONG $0x003f870f; WORD $0x0000 // ja LBB14_98, $63(%rip) + LONG $0xff4d8d4d // leaq $-1(%r13), %r9 + WORD $0xff31 // xorl %edi, %edi + +LBB14_95: + WORD $0xfa89 // movl %edi, %edx + LONG $0x2710ff81; WORD $0x0000 // cmpl $10000, %edi + WORD $0x3c8d; BYTE $0x92 // leal (%rdx,%rdx,4), %edi + LONG $0xf6b60f40 // movzbl %sil, %esi + LONG $0xd07e7c8d // leal $-48(%rsi,%rdi,2), %edi + WORD $0x4d0f; BYTE $0xfa // cmovgel %edx, %edi + WORD $0x3949; BYTE $0xc1 // cmpq %rax, %r9 + LONG $0x0021840f; WORD $0x0000 // je LBB14_99, $33(%rip) + LONG $0x74b60f41; WORD $0x0107 // movzbl $1(%r15,%rax), %esi WORD $0xff48; BYTE $0xc0 // incq %rax - WORD $0x3949; BYTE $0xc5 // cmpq %rax, %r13 - LONG $0xffd0850f; WORD $0xffff // jne LBB19_90, $-48(%rip) - WORD $0x894c; BYTE $0xe8 // movq %r13, %rax + WORD $0x568d; BYTE $0xd0 // leal $-48(%rsi), %edx + WORD $0xfa80; BYTE $0x0a // cmpb $10, %dl + LONG $0xffcc820f; WORD $0xffff // jb LBB14_95, $-52(%rip) + LONG $0x00000ae9; BYTE $0x00 // jmp LBB14_100, $10(%rip) -LBB19_93: - LONG $0xf0af0f41 // imull %r8d, %esi - WORD $0xce01 // addl %ecx, %esi - WORD $0x8949; BYTE $0xc5 // movq %rax, %r13 - LONG $0xfffd7de9; BYTE $0xff // jmp LBB19_60, $-643(%rip) - QUAD $0x9090909090909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 +LBB14_98: + WORD $0xff31 // xorl %edi, %edi + LONG $0x000003e9; BYTE $0x00 // jmp LBB14_100, $3(%rip) + +LBB14_99: + WORD $0x894c; BYTE $0xe8 // movq %r13, %rax + +LBB14_100: + WORD $0x8948; BYTE $0xfe // movq %rdi, %rsi + LONG $0xf0af0f41 // imull %r8d, %esi + WORD $0xce01 // addl %ecx, %esi + WORD $0x8949; BYTE $0xc5 // movq %rax, %r13 + LONG $0xfffd3be9; BYTE $0xff // jmp LBB14_62, $-709(%rip) + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 _vsigned: BYTE $0x55 // pushq %rbp @@ -5480,76 +5042,77 @@ _vsigned: WORD $0x8b4c; BYTE $0x0f // movq (%rdi), %r9 LONG $0x085f8b4c // movq $8(%rdi), %r11 LONG $0x0902c748; WORD $0x0000; BYTE $0x00 // movq $9, (%rdx) - WORD $0x570f; BYTE $0xc0 // xorps %xmm0, %xmm0 - LONG $0x0842110f // movups %xmm0, $8(%rdx) + QUAD $0x000000000842c748 // movq $0, $8(%rdx) + QUAD $0x000000001042c748 // movq $0, $16(%rdx) WORD $0x8b48; BYTE $0x0e // movq (%rsi), %rcx LONG $0x184a8948 // movq %rcx, $24(%rdx) WORD $0x394c; BYTE $0xd8 // cmpq %r11, %rax - LONG $0x0046830f; WORD $0x0000 // jae LBB20_1, $70(%rip) - LONG $0x0cb60f41; BYTE $0x01 // movzbl (%r9,%rax), %ecx + LONG $0x0044830f; WORD $0x0000 // jae LBB15_1, $68(%rip) + LONG $0x010c8a41 // movb (%r9,%rax), %cl LONG $0x0001b841; WORD $0x0000 // movl $1, %r8d WORD $0xf980; BYTE $0x2d // cmpb $45, %cl - LONG $0x0018850f; WORD $0x0000 // jne LBB20_5, $24(%rip) + LONG $0x0017850f; WORD $0x0000 // jne LBB15_5, $23(%rip) WORD $0xff48; BYTE $0xc0 // incq %rax WORD $0x394c; BYTE $0xd8 // cmpq %r11, %rax - LONG $0x0026830f; WORD $0x0000 // jae LBB20_1, $38(%rip) - LONG $0x0cb60f41; BYTE $0x01 // movzbl (%r9,%rax), %ecx + LONG $0x0025830f; WORD $0x0000 // jae LBB15_1, $37(%rip) + LONG $0x010c8a41 // movb (%r9,%rax), %cl LONG $0xffc0c749; WORD $0xffff; BYTE $0xff // movq $-1, %r8 -LBB20_5: - WORD $0x798d; BYTE $0xc6 // leal $-58(%rcx), %edi - LONG $0xf5ff8040 // cmpb $-11, %dil - LONG $0x001a870f; WORD $0x0000 // ja LBB20_7, $26(%rip) +LBB15_5: + WORD $0x798d; BYTE $0xd0 // leal $-48(%rcx), %edi + LONG $0x0aff8040 // cmpb $10, %dil + LONG $0x001a820f; WORD $0x0000 // jb LBB15_7, $26(%rip) WORD $0x8948; BYTE $0x06 // movq %rax, (%rsi) LONG $0xfe02c748; WORD $0xffff; BYTE $0xff // movq $-2, (%rdx) BYTE $0x5b // popq %rbx BYTE $0x5d // popq %rbp BYTE $0xc3 // retq -LBB20_1: +LBB15_1: WORD $0x894c; BYTE $0x1e // movq %r11, (%rsi) LONG $0xff02c748; WORD $0xffff; BYTE $0xff // movq $-1, (%rdx) BYTE $0x5b // popq %rbx BYTE $0x5d // popq %rbp BYTE $0xc3 // retq -LBB20_7: +LBB15_7: WORD $0xf980; BYTE $0x30 // cmpb $48, %cl - LONG $0x0032850f; WORD $0x0000 // jne LBB20_12, $50(%rip) - LONG $0x01508d4c // leaq $1(%rax), %r10 + LONG $0x0035850f; WORD $0x0000 // jne LBB15_12, $53(%rip) + LONG $0x01788d48 // leaq $1(%rax), %rdi WORD $0x394c; BYTE $0xd8 // cmpq %r11, %rax - LONG $0x0081830f; WORD $0x0000 // jae LBB20_11, $129(%rip) - LONG $0x3cb60f43; BYTE $0x11 // movzbl (%r9,%r10), %edi - WORD $0xc783; BYTE $0xd2 // addl $-46, %edi - WORD $0xff83; BYTE $0x37 // cmpl $55, %edi - LONG $0x0070870f; WORD $0x0000 // ja LBB20_11, $112(%rip) + LONG $0x008a830f; WORD $0x0000 // jae LBB15_11, $138(%rip) + LONG $0x390c8a41 // movb (%r9,%rdi), %cl + WORD $0xc180; BYTE $0xd2 // addb $-46, %cl + WORD $0xf980; BYTE $0x37 // cmpb $55, %cl + LONG $0x007a870f; WORD $0x0000 // ja LBB15_11, $122(%rip) + LONG $0xd1b60f44 // movzbl %cl, %r10d QUAD $0x000000800001b948; WORD $0x0080 // movabsq $36028797027352577, %rcx - LONG $0xf9a30f48 // btq %rdi, %rcx - LONG $0x005c830f; WORD $0x0000 // jae LBB20_11, $92(%rip) + LONG $0xd1a30f4c // btq %r10, %rcx + LONG $0x0062830f; WORD $0x0000 // jae LBB15_11, $98(%rip) -LBB20_12: - WORD $0x394c; BYTE $0xd8 // cmpq %r11, %rax - WORD $0x894d; BYTE $0xda // movq %r11, %r10 - LONG $0xd0470f4c // cmovaq %rax, %r10 - WORD $0xc931 // xorl %ecx, %ecx - QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90 +LBB15_12: + WORD $0x394c; BYTE $0xd8 // cmpq %r11, %rax + WORD $0x894d; BYTE $0xda // movq %r11, %r10 + LONG $0xd0470f4c // cmovaq %rax, %r10 + WORD $0xc931 // xorl %ecx, %ecx + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 -LBB20_13: - WORD $0x394c; BYTE $0xd8 // cmpq %r11, %rax - LONG $0x007d830f; WORD $0x0000 // jae LBB20_23, $125(%rip) +LBB15_13: + WORD $0x3949; BYTE $0xc2 // cmpq %rax, %r10 + LONG $0x007f840f; WORD $0x0000 // je LBB15_23, $127(%rip) LONG $0x3cbe0f49; BYTE $0x01 // movsbq (%r9,%rax), %rdi WORD $0x5f8d; BYTE $0xd0 // leal $-48(%rdi), %ebx WORD $0xfb80; BYTE $0x09 // cmpb $9, %bl - LONG $0x0033870f; WORD $0x0000 // ja LBB20_18, $51(%rip) + LONG $0x0033870f; WORD $0x0000 // ja LBB15_18, $51(%rip) LONG $0x0ac96b48 // imulq $10, %rcx, %rcx - LONG $0x0013800f; WORD $0x0000 // jo LBB20_17, $19(%rip) + LONG $0x0013800f; WORD $0x0000 // jo LBB15_17, $19(%rip) WORD $0xff48; BYTE $0xc0 // incq %rax WORD $0xc783; BYTE $0xd0 // addl $-48, %edi LONG $0xf8af0f49 // imulq %r8, %rdi WORD $0x0148; BYTE $0xf9 // addq %rdi, %rcx - LONG $0xffc9810f; WORD $0xffff // jno LBB20_13, $-55(%rip) + LONG $0xffc9810f; WORD $0xffff // jno LBB15_13, $-55(%rip) -LBB20_17: +LBB15_17: WORD $0xff48; BYTE $0xc8 // decq %rax WORD $0x8948; BYTE $0x06 // movq %rax, (%rsi) LONG $0xfb02c748; WORD $0xffff; BYTE $0xff // movq $-5, (%rdx) @@ -5557,169 +5120,160 @@ LBB20_17: BYTE $0x5d // popq %rbp BYTE $0xc3 // retq -LBB20_11: - WORD $0x894c; BYTE $0x16 // movq %r10, (%rsi) +LBB15_11: + WORD $0x8948; BYTE $0x3e // movq %rdi, (%rsi) BYTE $0x5b // popq %rbx BYTE $0x5d // popq %rbp BYTE $0xc3 // retq -LBB20_18: +LBB15_18: WORD $0x394c; BYTE $0xd8 // cmpq %r11, %rax - LONG $0x002d830f; WORD $0x0000 // jae LBB20_22, $45(%rip) - LONG $0x3cb60f41; BYTE $0x01 // movzbl (%r9,%rax), %edi - WORD $0xff83; BYTE $0x2e // cmpl $46, %edi - LONG $0x0012840f; WORD $0x0000 // je LBB20_25, $18(%rip) - WORD $0xff83; BYTE $0x45 // cmpl $69, %edi - LONG $0x0009840f; WORD $0x0000 // je LBB20_25, $9(%rip) - WORD $0xff83; BYTE $0x65 // cmpl $101, %edi - LONG $0x000d850f; WORD $0x0000 // jne LBB20_22, $13(%rip) - -LBB20_25: + LONG $0x002f830f; WORD $0x0000 // jae LBB15_22, $47(%rip) + LONG $0x013c8a41 // movb (%r9,%rax), %dil + LONG $0x2eff8040 // cmpb $46, %dil + LONG $0x0014840f; WORD $0x0000 // je LBB15_25, $20(%rip) + LONG $0x45ff8040 // cmpb $69, %dil + LONG $0x000a840f; WORD $0x0000 // je LBB15_25, $10(%rip) + LONG $0x65ff8040 // cmpb $101, %dil + LONG $0x000d850f; WORD $0x0000 // jne LBB15_22, $13(%rip) + +LBB15_25: WORD $0x8948; BYTE $0x06 // movq %rax, (%rsi) LONG $0xfa02c748; WORD $0xffff; BYTE $0xff // movq $-6, (%rdx) BYTE $0x5b // popq %rbx BYTE $0x5d // popq %rbp BYTE $0xc3 // retq -LBB20_22: +LBB15_22: WORD $0x8949; BYTE $0xc2 // movq %rax, %r10 -LBB20_23: - WORD $0x894c; BYTE $0x16 // movq %r10, (%rsi) - LONG $0x104a8948 // movq %rcx, $16(%rdx) - BYTE $0x5b // popq %rbx - BYTE $0x5d // popq %rbp - BYTE $0xc3 // retq +LBB15_23: + WORD $0x894c; BYTE $0x16 // movq %r10, (%rsi) + LONG $0x104a8948 // movq %rcx, $16(%rdx) + BYTE $0x5b // popq %rbx + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 - // .p2align 4, 0x90 _vunsigned: BYTE $0x55 // pushq %rbp WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp - WORD $0x5641 // pushq %r14 BYTE $0x53 // pushq %rbx WORD $0x8949; BYTE $0xd0 // movq %rdx, %r8 WORD $0x8b48; BYTE $0x0e // movq (%rsi), %rcx WORD $0x8b4c; BYTE $0x0f // movq (%rdi), %r9 - LONG $0x08778b4c // movq $8(%rdi), %r14 + LONG $0x085f8b4c // movq $8(%rdi), %r11 LONG $0x0902c748; WORD $0x0000; BYTE $0x00 // movq $9, (%rdx) - WORD $0x570f; BYTE $0xc0 // xorps %xmm0, %xmm0 - LONG $0x0842110f // movups %xmm0, $8(%rdx) + QUAD $0x000000000842c748 // movq $0, $8(%rdx) + QUAD $0x000000001042c748 // movq $0, $16(%rdx) WORD $0x8b48; BYTE $0x06 // movq (%rsi), %rax LONG $0x18428948 // movq %rax, $24(%rdx) - WORD $0x394c; BYTE $0xf1 // cmpq %r14, %rcx - LONG $0x001c830f; WORD $0x0000 // jae LBB21_1, $28(%rip) - LONG $0x04b60f41; BYTE $0x09 // movzbl (%r9,%rcx), %eax + WORD $0x394c; BYTE $0xd9 // cmpq %r11, %rcx + LONG $0x0019830f; WORD $0x0000 // jae LBB16_1, $25(%rip) + LONG $0x09048a41 // movb (%r9,%rcx), %al WORD $0x2d3c // cmpb $45, %al - LONG $0x001e850f; WORD $0x0000 // jne LBB21_4, $30(%rip) + LONG $0x001a850f; WORD $0x0000 // jne LBB16_4, $26(%rip) -LBB21_3: +LBB16_3: WORD $0x8948; BYTE $0x0e // movq %rcx, (%rsi) LONG $0xfa00c749; WORD $0xffff; BYTE $0xff // movq $-6, (%r8) BYTE $0x5b // popq %rbx - WORD $0x5e41 // popq %r14 BYTE $0x5d // popq %rbp BYTE $0xc3 // retq -LBB21_1: - WORD $0x894c; BYTE $0x36 // movq %r14, (%rsi) +LBB16_1: + WORD $0x894c; BYTE $0x1e // movq %r11, (%rsi) LONG $0xff00c749; WORD $0xffff; BYTE $0xff // movq $-1, (%r8) BYTE $0x5b // popq %rbx - WORD $0x5e41 // popq %r14 BYTE $0x5d // popq %rbp BYTE $0xc3 // retq -LBB21_4: - WORD $0x508d; BYTE $0xc6 // leal $-58(%rax), %edx - WORD $0xfa80; BYTE $0xf5 // cmpb $-11, %dl - LONG $0x000f870f; WORD $0x0000 // ja LBB21_6, $15(%rip) +LBB16_4: + WORD $0x508d; BYTE $0xd0 // leal $-48(%rax), %edx + WORD $0xfa80; BYTE $0x0a // cmpb $10, %dl + LONG $0x000d820f; WORD $0x0000 // jb LBB16_6, $13(%rip) WORD $0x8948; BYTE $0x0e // movq %rcx, (%rsi) LONG $0xfe00c749; WORD $0xffff; BYTE $0xff // movq $-2, (%r8) BYTE $0x5b // popq %rbx - WORD $0x5e41 // popq %r14 BYTE $0x5d // popq %rbp BYTE $0xc3 // retq -LBB21_6: +LBB16_6: WORD $0x303c // cmpb $48, %al - LONG $0x0026850f; WORD $0x0000 // jne LBB21_10, $38(%rip) - LONG $0x44b60f41; WORD $0x0109 // movzbl $1(%r9,%rcx), %eax - WORD $0xc083; BYTE $0xd2 // addl $-46, %eax - WORD $0xf883; BYTE $0x37 // cmpl $55, %eax - LONG $0x00c2870f; WORD $0x0000 // ja LBB21_9, $194(%rip) + LONG $0x0026850f; WORD $0x0000 // jne LBB16_7, $38(%rip) + LONG $0x09448a41; BYTE $0x01 // movb $1(%r9,%rcx), %al + WORD $0xd204 // addb $-46, %al + WORD $0x373c // cmpb $55, %al + LONG $0x00af870f; WORD $0x0000 // ja LBB16_16, $175(%rip) + WORD $0xb60f; BYTE $0xc0 // movzbl %al, %eax QUAD $0x000000800001ba48; WORD $0x0080 // movabsq $36028797027352577, %rdx LONG $0xc2a30f48 // btq %rax, %rdx - LONG $0x00ae830f; WORD $0x0000 // jae LBB21_9, $174(%rip) + LONG $0x0098830f; WORD $0x0000 // jae LBB16_16, $152(%rip) -LBB21_10: - WORD $0x3949; BYTE $0xce // cmpq %rcx, %r14 - WORD $0x8949; BYTE $0xca // movq %rcx, %r10 - LONG $0xd6470f4d // cmovaq %r14, %r10 +LBB16_7: WORD $0xc031 // xorl %eax, %eax - LONG $0x000abb41; WORD $0x0000 // movl $10, %r11d - QUAD $0x9090909090909090 // .p2align 4, 0x90 + LONG $0x000aba41; WORD $0x0000 // movl $10, %r10d + WORD $0x9090 // .p2align 4, 0x90 -LBB21_11: - WORD $0x394c; BYTE $0xf1 // cmpq %r14, %rcx - LONG $0x007f830f; WORD $0x0000 // jae LBB21_22, $127(%rip) - LONG $0x1cbe0f41; BYTE $0x09 // movsbl (%r9,%rcx), %ebx - WORD $0x538d; BYTE $0xd0 // leal $-48(%rbx), %edx +LBB16_8: + WORD $0x3949; BYTE $0xcb // cmpq %rcx, %r11 + LONG $0x007b840f; WORD $0x0000 // je LBB16_22, $123(%rip) + LONG $0x3cbe0f41; BYTE $0x09 // movsbl (%r9,%rcx), %edi + WORD $0x578d; BYTE $0xd0 // leal $-48(%rdi), %edx WORD $0xfa80; BYTE $0x09 // cmpb $9, %dl - LONG $0x0042870f; WORD $0x0000 // ja LBB21_17, $66(%rip) - WORD $0xf749; BYTE $0xe3 // mulq %r11 - LONG $0x0027800f; WORD $0x0000 // jo LBB21_16, $39(%rip) + LONG $0x003f870f; WORD $0x0000 // ja LBB16_17, $63(%rip) + WORD $0xf749; BYTE $0xe2 // mulq %r10 + LONG $0x0026800f; WORD $0x0000 // jo LBB16_13, $38(%rip) WORD $0xff48; BYTE $0xc1 // incq %rcx - WORD $0xc383; BYTE $0xd0 // addl $-48, %ebx - WORD $0xff31 // xorl %edi, %edi - WORD $0x0148; BYTE $0xd8 // addq %rbx, %rax - LONG $0xc7920f40 // setb %dil - WORD $0x8948; BYTE $0xfa // movq %rdi, %rdx + WORD $0xc783; BYTE $0xd0 // addl $-48, %edi + WORD $0xdb31 // xorl %ebx, %ebx + WORD $0x0148; BYTE $0xf8 // addq %rdi, %rax + WORD $0x920f; BYTE $0xc3 // setb %bl + WORD $0x8948; BYTE $0xda // movq %rbx, %rdx WORD $0xf748; BYTE $0xda // negq %rdx - WORD $0x3148; BYTE $0xd7 // xorq %rdx, %rdi - LONG $0x0009850f; WORD $0x0000 // jne LBB21_16, $9(%rip) + WORD $0x3148; BYTE $0xd3 // xorq %rdx, %rbx + LONG $0x0009850f; WORD $0x0000 // jne LBB16_13, $9(%rip) WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx - LONG $0xffb6890f; WORD $0xffff // jns LBB21_11, $-74(%rip) + LONG $0xffb7890f; WORD $0xffff // jns LBB16_8, $-73(%rip) -LBB21_16: +LBB16_13: WORD $0xff48; BYTE $0xc9 // decq %rcx WORD $0x8948; BYTE $0x0e // movq %rcx, (%rsi) LONG $0xfb00c749; WORD $0xffff; BYTE $0xff // movq $-5, (%r8) BYTE $0x5b // popq %rbx - WORD $0x5e41 // popq %r14 BYTE $0x5d // popq %rbp BYTE $0xc3 // retq -LBB21_17: - WORD $0x394c; BYTE $0xf1 // cmpq %r14, %rcx - LONG $0x0020830f; WORD $0x0000 // jae LBB21_21, $32(%rip) - LONG $0x14b60f41; BYTE $0x09 // movzbl (%r9,%rcx), %edx - WORD $0xfa83; BYTE $0x2e // cmpl $46, %edx - LONG $0xff0c840f; WORD $0xffff // je LBB21_3, $-244(%rip) - WORD $0xfa83; BYTE $0x45 // cmpl $69, %edx - LONG $0xff03840f; WORD $0xffff // je LBB21_3, $-253(%rip) - WORD $0xfa83; BYTE $0x65 // cmpl $101, %edx - LONG $0xfefa840f; WORD $0xffff // je LBB21_3, $-262(%rip) - -LBB21_21: - WORD $0x8949; BYTE $0xca // movq %rcx, %r10 - -LBB21_22: - WORD $0x894c; BYTE $0x16 // movq %r10, (%rsi) +LBB16_17: + WORD $0x394c; BYTE $0xd9 // cmpq %r11, %rcx + LONG $0x001f830f; WORD $0x0000 // jae LBB16_21, $31(%rip) + LONG $0x09148a41 // movb (%r9,%rcx), %dl + WORD $0xfa80; BYTE $0x2e // cmpb $46, %dl + LONG $0xff26840f; WORD $0xffff // je LBB16_3, $-218(%rip) + WORD $0xfa80; BYTE $0x45 // cmpb $69, %dl + LONG $0xff1d840f; WORD $0xffff // je LBB16_3, $-227(%rip) + WORD $0xfa80; BYTE $0x65 // cmpb $101, %dl + LONG $0xff14840f; WORD $0xffff // je LBB16_3, $-236(%rip) + +LBB16_21: + WORD $0x8949; BYTE $0xcb // movq %rcx, %r11 + +LBB16_22: + WORD $0x894c; BYTE $0x1e // movq %r11, (%rsi) LONG $0x10408949 // movq %rax, $16(%r8) BYTE $0x5b // popq %rbx - WORD $0x5e41 // popq %r14 BYTE $0x5d // popq %rbp BYTE $0xc3 // retq -LBB21_9: - WORD $0xff48; BYTE $0xc1 // incq %rcx - WORD $0x8948; BYTE $0x0e // movq %rcx, (%rsi) - BYTE $0x5b // popq %rbx - WORD $0x5e41 // popq %r14 - BYTE $0x5d // popq %rbp - BYTE $0xc3 // retq - BYTE $0x00 // .p2align 4, 0x00 +LBB16_16: + WORD $0xff48; BYTE $0xc1 // incq %rcx + WORD $0x8948; BYTE $0x0e // movq %rcx, (%rsi) + BYTE $0x5b // popq %rbx + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + QUAD $0x0000000000000000; BYTE $0x00 // .p2align 4, 0x00 -LCPI22_0: +LCPI17_0: QUAD $0x0000000000000001 // .quad 1 QUAD $0x0000000000000005 // .quad 5 @@ -5730,7 +5284,7 @@ _skip_array: WORD $0x8948; BYTE $0xd0 // movq %rdx, %rax WORD $0x8948; BYTE $0xf2 // movq %rsi, %rdx WORD $0x8948; BYTE $0xfe // movq %rdi, %rsi - LONG $0xdc05280f; WORD $0xffff; BYTE $0xff // movaps $-36(%rip), %xmm0 /* LCPI22_0(%rip) */ + LONG $0xdc05280f; WORD $0xffff; BYTE $0xff // movaps $-36(%rip), %xmm0 /* LCPI17_0(%rip) */ WORD $0x110f; BYTE $0x00 // movups %xmm0, (%rax) WORD $0x8948; BYTE $0xc7 // movq %rax, %rdi BYTE $0x5d // popq %rbp @@ -5748,294 +5302,394 @@ _fsm_exec: LONG $0x28ec8348 // subq $40, %rsp LONG $0xb84d8948 // movq %rcx, $-72(%rbp) LONG $0x003f8348 // cmpq $0, (%rdi) - LONG $0x03b1840f; WORD $0x0000 // je LBB23_2, $945(%rip) - WORD $0x8949; BYTE $0xd4 // movq %rdx, %r12 - WORD $0x8949; BYTE $0xff // movq %rdi, %r15 - LONG $0xd0758948 // movq %rsi, $-48(%rbp) + LONG $0x0591840f; WORD $0x0000 // je LBB18_76, $1425(%rip) + WORD $0x8949; BYTE $0xd0 // movq %rdx, %r8 + WORD $0x8949; BYTE $0xfc // movq %rdi, %r12 + LONG $0x08468d48 // leaq $8(%rsi), %rax + LONG $0xd0458948 // movq %rax, $-48(%rbp) LONG $0xffc6c749; WORD $0xffff; BYTE $0xff // movq $-1, %r14 - LONG $0xc8558948 // movq %rdx, $-56(%rbp) - LONG $0x000033e9; BYTE $0x00 // jmp LBB23_7, $51(%rip) - -LBB23_3: - WORD $0x8b49; BYTE $0x0f // movq (%r15), %rcx - LONG $0x000006b8; BYTE $0x00 // movl $6, %eax - LONG $0xfff98148; WORD $0x000f; BYTE $0x00 // cmpq $4095, %rcx - LONG $0x03a78f0f; WORD $0x0000 // jg LBB23_62, $935(%rip) - WORD $0x9090 // .p2align 4, 0x90 + QUAD $0x000100002600bb49; WORD $0x0000 // movabsq $4294977024, %r11 + LONG $0xc0758948 // movq %rsi, $-64(%rbp) + LONG $0x000029e9; BYTE $0x00 // jmp LBB18_3, $41(%rip) -LBB23_4: - LONG $0x01518d48 // leaq $1(%rcx), %rdx - WORD $0x8949; BYTE $0x17 // movq %rdx, (%r15) - WORD $0x8948; BYTE $0xca // movq %rcx, %rdx +LBB18_2: + LONG $0x03488d48 // leaq $3(%rax), %rcx + WORD $0x8949; BYTE $0x08 // movq %rcx, (%r8) + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0x05a98e0f; WORD $0x0000 // jle LBB18_83, $1449(%rip) + QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90 -LBB23_5: - LONG $0xd7448949; BYTE $0x08 // movq %rax, $8(%r15,%rdx,8) +LBB18_61: + LONG $0x24148b4d // movq (%r12), %r10 + WORD $0x894d; BYTE $0xf7 // movq %r14, %r15 + WORD $0x854d; BYTE $0xd2 // testq %r10, %r10 + LONG $0x0547840f; WORD $0x0000 // je LBB18_77, $1351(%rip) -LBB23_6: - LONG $0x003f8349 // cmpq $0, (%r15) - WORD $0x894c; BYTE $0xf0 // movq %r14, %rax - LONG $0x035c840f; WORD $0x0000 // je LBB23_54, $860(%rip) +LBB18_3: + WORD $0x894d; BYTE $0xf1 // movq %r14, %r9 + WORD $0x8b48; BYTE $0x3e // movq (%rsi), %rdi + LONG $0x084e8b48 // movq $8(%rsi), %rcx + WORD $0x8b49; BYTE $0x00 // movq (%r8), %rax + WORD $0x8948; BYTE $0xc2 // movq %rax, %rdx + WORD $0x2948; BYTE $0xca // subq %rcx, %rdx + LONG $0x0037830f; WORD $0x0000 // jae LBB18_8, $55(%rip) + WORD $0x1c8a; BYTE $0x07 // movb (%rdi,%rax), %bl + WORD $0xfb80; BYTE $0x0d // cmpb $13, %bl + LONG $0x002b840f; WORD $0x0000 // je LBB18_8, $43(%rip) + WORD $0xfb80; BYTE $0x20 // cmpb $32, %bl + LONG $0x0022840f; WORD $0x0000 // je LBB18_8, $34(%rip) + WORD $0xc380; BYTE $0xf7 // addb $-9, %bl + WORD $0xfb80; BYTE $0x01 // cmpb $1, %bl + LONG $0x0016860f; WORD $0x0000 // jbe LBB18_8, $22(%rip) + WORD $0x8949; BYTE $0xc6 // movq %rax, %r14 + LONG $0x000130e9; BYTE $0x00 // jmp LBB18_29, $304(%rip) + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 -LBB23_7: - LONG $0xd06d8b4c // movq $-48(%rbp), %r13 - LONG $0x007d8b49 // movq (%r13), %rdi - LONG $0x08758b49 // movq $8(%r13), %rsi - WORD $0x894c; BYTE $0xe2 // movq %r12, %rdx - LONG $0xffee30e8; BYTE $0xff // callq _advance_ns, $-4560(%rip) - WORD $0xc084 // testb %al, %al - LONG $0x0348840f; WORD $0x0000 // je LBB23_2, $840(%rip) - LONG $0xfffe8349 // cmpq $-1, %r14 - LONG $0x0007850f; WORD $0x0000 // jne LBB23_10, $7(%rip) - LONG $0x24348b4d // movq (%r12), %r14 - WORD $0xff49; BYTE $0xce // decq %r14 +LBB18_8: + LONG $0x01708d4c // leaq $1(%rax), %r14 + WORD $0x3949; BYTE $0xce // cmpq %rcx, %r14 + LONG $0x0023830f; WORD $0x0000 // jae LBB18_12, $35(%rip) + LONG $0x371c8a42 // movb (%rdi,%r14), %bl + WORD $0xfb80; BYTE $0x0d // cmpb $13, %bl + LONG $0x0016840f; WORD $0x0000 // je LBB18_12, $22(%rip) + WORD $0xfb80; BYTE $0x20 // cmpb $32, %bl + LONG $0x000d840f; WORD $0x0000 // je LBB18_12, $13(%rip) + WORD $0xc380; BYTE $0xf7 // addb $-9, %bl + WORD $0xfb80; BYTE $0x01 // cmpb $1, %bl + LONG $0x00f3870f; WORD $0x0000 // ja LBB18_29, $243(%rip) + BYTE $0x90 // .p2align 4, 0x90 -LBB23_10: - WORD $0xbe0f; BYTE $0xf0 // movsbl %al, %esi - WORD $0x8b49; BYTE $0x0f // movq (%r15), %rcx - LONG $0xff518d48 // leaq $-1(%rcx), %rdx - LONG $0xcf3c8b41 // movl (%r15,%rcx,8), %edi - WORD $0xcfff // decl %edi - WORD $0xff83; BYTE $0x05 // cmpl $5, %edi - LONG $0x0027870f; WORD $0x0000 // ja LBB23_14, $39(%rip) - LONG $0x7b1d8d48; WORD $0x0004; BYTE $0x00 // leaq $1147(%rip), %rbx /* LJTI23_0(%rip) */ - LONG $0xbb3c6348 // movslq (%rbx,%rdi,4), %rdi - WORD $0x0148; BYTE $0xdf // addq %rbx, %rdi - JMP DI - -LBB23_12: - WORD $0xfe83; BYTE $0x2c // cmpl $44, %esi - LONG $0x01a8840f; WORD $0x0000 // je LBB23_35, $424(%rip) - WORD $0xfe83; BYTE $0x5d // cmpl $93, %esi - LONG $0x016c840f; WORD $0x0000 // je LBB23_32, $364(%rip) - LONG $0x000310e9; BYTE $0x00 // jmp LBB23_58, $784(%rip) - -LBB23_14: - WORD $0x8949; BYTE $0x17 // movq %rdx, (%r15) - LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq $-2, %rax - WORD $0xfe83; BYTE $0x7b // cmpl $123, %esi - LONG $0x0099860f; WORD $0x0000 // jbe LBB23_26, $153(%rip) - LONG $0x0002d7e9; BYTE $0x00 // jmp LBB23_54, $727(%rip) - -LBB23_15: - WORD $0xfe83; BYTE $0x7d // cmpl $125, %esi - LONG $0x0146840f; WORD $0x0000 // je LBB23_32, $326(%rip) - WORD $0xfe83; BYTE $0x2c // cmpl $44, %esi - LONG $0x02e6850f; WORD $0x0000 // jne LBB23_58, $742(%rip) - LONG $0x000003b8; BYTE $0x00 // movl $3, %eax - LONG $0xfff98148; WORD $0x000f; BYTE $0x00 // cmpq $4095, %rcx - LONG $0xff3b8e0f; WORD $0xffff // jle LBB23_4, $-197(%rip) - LONG $0x0002dbe9; BYTE $0x00 // jmp LBB23_62, $731(%rip) - -LBB23_18: - WORD $0x223c // cmpb $34, %al - LONG $0x02c7850f; WORD $0x0000 // jne LBB23_58, $711(%rip) - QUAD $0x00000004cf04c749 // movq $4, (%r15,%rcx,8) - LONG $0x241c8b49 // movq (%r12), %rbx - WORD $0x894c; BYTE $0xef // movq %r13, %rdi - -LBB23_20: - WORD $0x8948; BYTE $0xde // movq %rbx, %rsi - LONG $0xc0558d48 // leaq $-64(%rbp), %rdx - LONG $0xb84d8b48 // movq $-72(%rbp), %rcx - LONG $0xfff08fe8; BYTE $0xff // callq _advance_string, $-3953(%rip) - WORD $0x8949; BYTE $0xc5 // movq %rax, %r13 - WORD $0x8548; BYTE $0xc0 // testq %rax, %rax - LONG $0x0107890f; WORD $0x0000 // jns LBB23_33, $263(%rip) - LONG $0xc0458b48 // movq $-64(%rbp), %rax - LONG $0x000107e9; BYTE $0x00 // jmp LBB23_34, $263(%rip) +LBB18_12: + LONG $0x02708d4c // leaq $2(%rax), %r14 + WORD $0x3949; BYTE $0xce // cmpq %rcx, %r14 + LONG $0x0023830f; WORD $0x0000 // jae LBB18_16, $35(%rip) + LONG $0x371c8a42 // movb (%rdi,%r14), %bl + WORD $0xfb80; BYTE $0x0d // cmpb $13, %bl + LONG $0x0016840f; WORD $0x0000 // je LBB18_16, $22(%rip) + WORD $0xfb80; BYTE $0x20 // cmpb $32, %bl + LONG $0x000d840f; WORD $0x0000 // je LBB18_16, $13(%rip) + WORD $0xc380; BYTE $0xf7 // addb $-9, %bl + WORD $0xfb80; BYTE $0x01 // cmpb $1, %bl + LONG $0x00c3870f; WORD $0x0000 // ja LBB18_29, $195(%rip) + BYTE $0x90 // .p2align 4, 0x90 -LBB23_22: - WORD $0x3a3c // cmpb $58, %al - LONG $0x028b850f; WORD $0x0000 // jne LBB23_58, $651(%rip) - WORD $0xc031 // xorl %eax, %eax - LONG $0xfffef5e9; BYTE $0xff // jmp LBB23_5, $-267(%rip) +LBB18_16: + LONG $0x03708d4c // leaq $3(%rax), %r14 + WORD $0x3949; BYTE $0xce // cmpq %rcx, %r14 + LONG $0x0023830f; WORD $0x0000 // jae LBB18_20, $35(%rip) + LONG $0x371c8a42 // movb (%rdi,%r14), %bl + WORD $0xfb80; BYTE $0x0d // cmpb $13, %bl + LONG $0x0016840f; WORD $0x0000 // je LBB18_20, $22(%rip) + WORD $0xfb80; BYTE $0x20 // cmpb $32, %bl + LONG $0x000d840f; WORD $0x0000 // je LBB18_20, $13(%rip) + WORD $0xc380; BYTE $0xf7 // addb $-9, %bl + WORD $0xfb80; BYTE $0x01 // cmpb $1, %bl + LONG $0x0093870f; WORD $0x0000 // ja LBB18_29, $147(%rip) + BYTE $0x90 // .p2align 4, 0x90 -LBB23_24: - WORD $0x5d3c // cmpb $93, %al - LONG $0x00d3840f; WORD $0x0000 // je LBB23_32, $211(%rip) - QUAD $0x00000001cf04c749 // movq $1, (%r15,%rcx,8) - LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq $-2, %rax - WORD $0xfe83; BYTE $0x7b // cmpl $123, %esi - LONG $0x0243870f; WORD $0x0000 // ja LBB23_54, $579(%rip) +LBB18_20: + LONG $0x04588d48 // leaq $4(%rax), %rbx + WORD $0x3948; BYTE $0xd9 // cmpq %rbx, %rcx + LONG $0x0450860f; WORD $0x0000 // jbe LBB18_75, $1104(%rip) + WORD $0x3948; BYTE $0xd9 // cmpq %rbx, %rcx + LONG $0x004a840f; WORD $0x0000 // je LBB18_26, $74(%rip) + LONG $0x0f1c8d48 // leaq (%rdi,%rcx), %rbx + LONG $0x04c28348 // addq $4, %rdx + LONG $0x07748d4c; BYTE $0x05 // leaq $5(%rdi,%rax), %r14 + QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 -LBB23_26: - WORD $0xf189 // movl %esi, %ecx - LONG $0xbe158d48; WORD $0x0003; BYTE $0x00 // leaq $958(%rip), %rdx /* LJTI23_1(%rip) */ - LONG $0x8a0c6348 // movslq (%rdx,%rcx,4), %rcx - WORD $0x0148; BYTE $0xd1 // addq %rdx, %rcx - LONG $0xffc5c749; WORD $0xffff; BYTE $0xff // movq $-1, %r13 - JMP CX +LBB18_23: + LONG $0x46be0f41; BYTE $0xff // movsbl $-1(%r14), %eax + WORD $0xf883; BYTE $0x20 // cmpl $32, %eax + LONG $0x0042870f; WORD $0x0000 // ja LBB18_28, $66(%rip) + LONG $0xc3a30f49 // btq %rax, %r11 + LONG $0x0038830f; WORD $0x0000 // jae LBB18_28, $56(%rip) + WORD $0xff49; BYTE $0xc6 // incq %r14 + WORD $0xff48; BYTE $0xc2 // incq %rdx + LONG $0xffdc850f; WORD $0xffff // jne LBB18_23, $-36(%rip) + LONG $0x00000ae9; BYTE $0x00 // jmp LBB18_27, $10(%rip) + LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 -LBB23_27: - LONG $0xc8458b48 // movq $-56(%rbp), %rax - WORD $0x8b48; BYTE $0x18 // movq (%rax), %rbx - LONG $0xff6b8d4c // leaq $-1(%rbx), %r13 +LBB18_26: + WORD $0x0148; BYTE $0xfb // addq %rdi, %rbx + +LBB18_27: + WORD $0x2948; BYTE $0xfb // subq %rdi, %rbx + WORD $0x8949; BYTE $0xde // movq %rbx, %r14 + WORD $0x3949; BYTE $0xce // cmpq %rcx, %r14 + LONG $0x0020820f; WORD $0x0000 // jb LBB18_29, $32(%rip) + LONG $0x0003e9e9; BYTE $0x00 // jmp LBB18_76, $1001(%rip) + QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB18_28: + WORD $0x8948; BYTE $0xfa // movq %rdi, %rdx + WORD $0xf748; BYTE $0xd2 // notq %rdx + WORD $0x0149; BYTE $0xd6 // addq %rdx, %r14 + WORD $0x3949; BYTE $0xce // cmpq %rcx, %r14 + LONG $0x03ce830f; WORD $0x0000 // jae LBB18_76, $974(%rip) + +LBB18_29: + LONG $0x014e8d49 // leaq $1(%r14), %rcx + WORD $0x8949; BYTE $0x08 // movq %rcx, (%r8) + LONG $0x0cbe0f42; BYTE $0x37 // movsbl (%rdi,%r14), %ecx + LONG $0xffc7c749; WORD $0xffff; BYTE $0xff // movq $-1, %r15 + WORD $0xc985 // testl %ecx, %ecx + LONG $0x03ba840f; WORD $0x0000 // je LBB18_77, $954(%rip) + LONG $0x242c8b4d // movq (%r12), %r13 + LONG $0xff558d4d // leaq $-1(%r13), %r10 + LONG $0xec1c8b43 // movl (%r12,%r13,8), %ebx + LONG $0xfff98349 // cmpq $-1, %r9 + LONG $0xf1450f4d // cmovneq %r9, %r14 + WORD $0xcbff // decl %ebx + WORD $0xfb83; BYTE $0x05 // cmpl $5, %ebx + LONG $0x0037870f; WORD $0x0000 // ja LBB18_35, $55(%rip) + LONG $0xfd158d48; WORD $0x0004; BYTE $0x00 // leaq $1277(%rip), %rdx /* LJTI18_0(%rip) */ + LONG $0x9a046348 // movslq (%rdx,%rbx,4), %rax + WORD $0x0148; BYTE $0xd0 // addq %rdx, %rax + JMP AX + +LBB18_32: + WORD $0xf983; BYTE $0x2c // cmpl $44, %ecx + LONG $0x0199840f; WORD $0x0000 // je LBB18_53, $409(%rip) + WORD $0xf983; BYTE $0x5d // cmpl $93, %ecx + LONG $0x03d6850f; WORD $0x0000 // jne LBB18_85, $982(%rip) + LONG $0x2414894d // movq %r10, (%r12) + WORD $0x894d; BYTE $0xf7 // movq %r14, %r15 + WORD $0x854d; BYTE $0xd2 // testq %r10, %r10 + LONG $0xfe22850f; WORD $0xffff // jne LBB18_3, $-478(%rip) + LONG $0x000364e9; BYTE $0x00 // jmp LBB18_77, $868(%rip) + +LBB18_35: + LONG $0x2414894d // movq %r10, (%r12) + WORD $0xf983; BYTE $0x7b // cmpl $123, %ecx + LONG $0x00f8860f; WORD $0x0000 // jbe LBB18_51, $248(%rip) + LONG $0x0003afe9; BYTE $0x00 // jmp LBB18_85, $943(%rip) + +LBB18_36: + WORD $0xf983; BYTE $0x2c // cmpl $44, %ecx + LONG $0x0183840f; WORD $0x0000 // je LBB18_55, $387(%rip) + WORD $0xf983; BYTE $0x7d // cmpl $125, %ecx + LONG $0x039d850f; WORD $0x0000 // jne LBB18_85, $925(%rip) + LONG $0x2414894d // movq %r10, (%r12) + WORD $0x894d; BYTE $0xf7 // movq %r14, %r15 + WORD $0x854d; BYTE $0xd2 // testq %r10, %r10 + LONG $0xfde9850f; WORD $0xffff // jne LBB18_3, $-535(%rip) + LONG $0x00032be9; BYTE $0x00 // jmp LBB18_77, $811(%rip) + +LBB18_39: + WORD $0xf980; BYTE $0x22 // cmpb $34, %cl + LONG $0x037f850f; WORD $0x0000 // jne LBB18_85, $895(%rip) + QUAD $0x00000004ec04c74b // movq $4, (%r12,%r13,8) + +LBB18_41: + QUAD $0xffffffffc845c748 // movq $-1, $-56(%rbp) + WORD $0x8b4d; BYTE $0x28 // movq (%r8), %r13 + WORD $0x8948; BYTE $0xf7 // movq %rsi, %rdi + WORD $0x894c; BYTE $0xee // movq %r13, %rsi + LONG $0xc8558d48 // leaq $-56(%rbp), %rdx + LONG $0xb84d8b48 // movq $-72(%rbp), %rcx + WORD $0x894c; BYTE $0xc3 // movq %r8, %rbx + LONG $0xffee32e8; BYTE $0xff // callq _advance_string, $-4558(%rip) + WORD $0x8949; BYTE $0xc7 // movq %rax, %r15 + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0x030b880f; WORD $0x0000 // js LBB18_78, $779(%rip) + WORD $0x894c; BYTE $0x3b // movq %r15, (%rbx) + WORD $0x854d; BYTE $0xed // testq %r13, %r13 + WORD $0x8949; BYTE $0xd8 // movq %rbx, %r8 + LONG $0xc0758b48 // movq $-64(%rbp), %rsi + QUAD $0x000100002600bb49; WORD $0x0000 // movabsq $4294977024, %r11 + LONG $0xfd798f0f; WORD $0xffff // jg LBB18_61, $-647(%rip) + LONG $0x000301e9; BYTE $0x00 // jmp LBB18_79, $769(%rip) + +LBB18_43: + WORD $0xf980; BYTE $0x3a // cmpb $58, %cl + LONG $0x031f850f; WORD $0x0000 // jne LBB18_85, $799(%rip) + QUAD $0x00000000ec04c74b // movq $0, (%r12,%r13,8) + LONG $0xfffd5ee9; BYTE $0xff // jmp LBB18_61, $-674(%rip) + +LBB18_45: + WORD $0xf980; BYTE $0x5d // cmpb $93, %cl + LONG $0x003c850f; WORD $0x0000 // jne LBB18_50, $60(%rip) + LONG $0x2414894d // movq %r10, (%r12) + WORD $0x894d; BYTE $0xf7 // movq %r14, %r15 + WORD $0x854d; BYTE $0xd2 // testq %r10, %r10 + LONG $0xfd55850f; WORD $0xffff // jne LBB18_3, $-683(%rip) + LONG $0x000297e9; BYTE $0x00 // jmp LBB18_77, $663(%rip) + +LBB18_47: + WORD $0xf983; BYTE $0x22 // cmpl $34, %ecx + LONG $0x00eb840f; WORD $0x0000 // je LBB18_57, $235(%rip) + WORD $0xf983; BYTE $0x7d // cmpl $125, %ecx + LONG $0x02e2850f; WORD $0x0000 // jne LBB18_85, $738(%rip) + LONG $0x2414894d // movq %r10, (%r12) + WORD $0x894d; BYTE $0xf7 // movq %r14, %r15 + WORD $0x854d; BYTE $0xd2 // testq %r10, %r10 + LONG $0xfd2e850f; WORD $0xffff // jne LBB18_3, $-722(%rip) + LONG $0x000270e9; BYTE $0x00 // jmp LBB18_77, $624(%rip) + +LBB18_50: + QUAD $0x00000001ec04c74b // movq $1, (%r12,%r13,8) + WORD $0xf983; BYTE $0x7b // cmpl $123, %ecx + LONG $0x02bc870f; WORD $0x0000 // ja LBB18_85, $700(%rip) + +LBB18_51: + WORD $0xc889 // movl %ecx, %eax + LONG $0xd70d8d48; WORD $0x0003; BYTE $0x00 // leaq $983(%rip), %rcx /* LJTI18_1(%rip) */ + LONG $0x81046348 // movslq (%rcx,%rax,4), %rax + WORD $0x0148; BYTE $0xc8 // addq %rcx, %rax + JMP AX + +LBB18_52: + WORD $0x8b49; BYTE $0x18 // movq (%r8), %rbx + LONG $0xff7b8d4c // leaq $-1(%rbx), %r15 + LONG $0x1f7c8d48; BYTE $0xff // leaq $-1(%rdi,%rbx), %rdi LONG $0xd0458b48 // movq $-48(%rbp), %rax - WORD $0x8b48; BYTE $0x38 // movq (%rax), %rdi - WORD $0x014c; BYTE $0xef // addq %r13, %rdi - LONG $0x08708b48 // movq $8(%rax), %rsi - WORD $0x294c; BYTE $0xee // subq %r13, %rsi - LONG $0x0006d1e8; BYTE $0x00 // callq _do_skip_number, $1745(%rip) + WORD $0x8b48; BYTE $0x30 // movq (%rax), %rsi + WORD $0x294c; BYTE $0xfe // subq %r15, %rsi + WORD $0x894d; BYTE $0xc5 // movq %r8, %r13 + LONG $0x000718e8; BYTE $0x00 // callq _do_skip_number, $1816(%rip) + QUAD $0x000100002600bb49; WORD $0x0000 // movabsq $4294977024, %r11 + LONG $0xc0758b48 // movq $-64(%rbp), %rsi + WORD $0x894d; BYTE $0xe8 // movq %r13, %r8 LONG $0xff488d48 // leaq $-1(%rax), %rcx LONG $0xfec2c748; WORD $0xffff; BYTE $0xff // movq $-2, %rdx WORD $0x2948; BYTE $0xc2 // subq %rax, %rdx WORD $0x8548; BYTE $0xc0 // testq %rax, %rax LONG $0xd1490f48 // cmovnsq %rcx, %rdx LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq $-2, %rax - LONG $0xe8480f4c // cmovsq %rax, %r13 + LONG $0xf8480f4c // cmovsq %rax, %r15 WORD $0x0148; BYTE $0xda // addq %rbx, %rdx - LONG $0xc8658b4c // movq $-56(%rbp), %r12 - LONG $0x24148949 // movq %rdx, (%r12) - WORD $0x854d; BYTE $0xed // testq %r13, %r13 - LONG $0xfe6c890f; WORD $0xffff // jns LBB23_6, $-404(%rip) - LONG $0x0001dfe9; BYTE $0x00 // jmp LBB23_55, $479(%rip) - -LBB23_28: - WORD $0xfe83; BYTE $0x7d // cmpl $125, %esi - LONG $0x003f840f; WORD $0x0000 // je LBB23_32, $63(%rip) - WORD $0xfe83; BYTE $0x22 // cmpl $34, %esi - LONG $0x01df850f; WORD $0x0000 // jne LBB23_58, $479(%rip) - QUAD $0x00000002cf04c749 // movq $2, (%r15,%rcx,8) - LONG $0x241c8b49 // movq (%r12), %rbx - WORD $0x894c; BYTE $0xef // movq %r13, %rdi - WORD $0x8948; BYTE $0xde // movq %rbx, %rsi - LONG $0xc0558d48 // leaq $-64(%rbp), %rdx - LONG $0xb84d8b48 // movq $-72(%rbp), %rcx - LONG $0xffefa7e8; BYTE $0xff // callq _advance_string, $-4185(%rip) - WORD $0x8949; BYTE $0xc5 // movq %rax, %r13 - WORD $0x8548; BYTE $0xc0 // testq %rax, %rax - LONG $0x0052890f; WORD $0x0000 // jns LBB23_37, $82(%rip) - LONG $0xc0458b48 // movq $-64(%rbp), %rax - LONG $0x000052e9; BYTE $0x00 // jmp LBB23_38, $82(%rip) - WORD $0x9090 // .p2align 4, 0x90 - -LBB23_32: - WORD $0x8949; BYTE $0x17 // movq %rdx, (%r15) - WORD $0x894d; BYTE $0xf5 // movq %r14, %r13 - WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx - LONG $0xfe1d850f; WORD $0xffff // jne LBB23_7, $-483(%rip) - LONG $0x000183e9; BYTE $0x00 // jmp LBB23_55, $387(%rip) - -LBB23_33: - WORD $0xff48; BYTE $0xcb // decq %rbx - WORD $0x894c; BYTE $0xe8 // movq %r13, %rax - WORD $0x8949; BYTE $0xdd // movq %rbx, %r13 - -LBB23_34: - LONG $0xc8658b4c // movq $-56(%rbp), %r12 - LONG $0x24048949 // movq %rax, (%r12) - WORD $0x854d; BYTE $0xed // testq %r13, %r13 - LONG $0xfdf1890f; WORD $0xffff // jns LBB23_6, $-527(%rip) - LONG $0x000164e9; BYTE $0x00 // jmp LBB23_55, $356(%rip) - -LBB23_35: - LONG $0xfff98148; WORD $0x000f; BYTE $0x00 // cmpq $4095, %rcx - LONG $0x01758f0f; WORD $0x0000 // jg LBB23_62, $373(%rip) - WORD $0xc031 // xorl %eax, %eax - LONG $0xfffdc9e9; BYTE $0xff // jmp LBB23_4, $-567(%rip) + LONG $0x00558949 // movq %rdx, (%r13) + WORD $0x854d; BYTE $0xff // testq %r15, %r15 + LONG $0xfc97890f; WORD $0xffff // jns LBB18_61, $-873(%rip) + LONG $0x0001e9e9; BYTE $0x00 // jmp LBB18_77, $489(%rip) -LBB23_37: - WORD $0xff48; BYTE $0xcb // decq %rbx - WORD $0x894c; BYTE $0xe8 // movq %r13, %rax - WORD $0x8949; BYTE $0xdd // movq %rbx, %r13 +LBB18_53: + LONG $0xfffd8149; WORD $0x000f; BYTE $0x00 // cmpq $4095, %r13 + LONG $0x01ee8f0f; WORD $0x0000 // jg LBB18_80, $494(%rip) + LONG $0x01458d49 // leaq $1(%r13), %rax + LONG $0x24048949 // movq %rax, (%r12) + QUAD $0x00000008ec44c74b; BYTE $0x00 // movq $0, $8(%r12,%r13,8) + LONG $0xfffc6fe9; BYTE $0xff // jmp LBB18_61, $-913(%rip) -LBB23_38: - LONG $0xc8658b4c // movq $-56(%rbp), %r12 +LBB18_55: + LONG $0xfffd8149; WORD $0x000f; BYTE $0x00 // cmpq $4095, %r13 + LONG $0x01cb8f0f; WORD $0x0000 // jg LBB18_80, $459(%rip) + LONG $0x01458d49 // leaq $1(%r13), %rax LONG $0x24048949 // movq %rax, (%r12) - WORD $0x854d; BYTE $0xed // testq %r13, %r13 - LONG $0x0136880f; WORD $0x0000 // js LBB23_55, $310(%rip) - WORD $0x8b49; BYTE $0x0f // movq (%r15), %rcx - LONG $0x000004b8; BYTE $0x00 // movl $4, %eax - LONG $0xfff98148; WORD $0x000f; BYTE $0x00 // cmpq $4095, %rcx - LONG $0xfd9a8e0f; WORD $0xffff // jle LBB23_4, $-614(%rip) - LONG $0x00013ae9; BYTE $0x00 // jmp LBB23_62, $314(%rip) - -LBB23_40: - LONG $0x241c8b49 // movq (%r12), %rbx - LONG $0xd07d8b48 // movq $-48(%rbp), %rdi - LONG $0xfffe69e9; BYTE $0xff // jmp LBB23_20, $-407(%rip) - -LBB23_41: - LONG $0x242c8b4d // movq (%r12), %r13 - LONG $0xd0458b48 // movq $-48(%rbp), %rax - WORD $0x8b48; BYTE $0x38 // movq (%rax), %rdi - WORD $0x014c; BYTE $0xef // addq %r13, %rdi - LONG $0x08708b48 // movq $8(%rax), %rsi - WORD $0x294c; BYTE $0xee // subq %r13, %rsi - LONG $0x0005aee8; BYTE $0x00 // callq _do_skip_number, $1454(%rip) - WORD $0x8548; BYTE $0xc0 // testq %rax, %rax - LONG $0x0126880f; WORD $0x0000 // js LBB23_66, $294(%rip) - WORD $0x014c; BYTE $0xe8 // addq %r13, %rax - LONG $0x24048949 // movq %rax, (%r12) - WORD $0x854d; BYTE $0xed // testq %r13, %r13 - LONG $0xfd648f0f; WORD $0xffff // jg LBB23_6, $-668(%rip) - LONG $0x000127e9; BYTE $0x00 // jmp LBB23_68, $295(%rip) - -LBB23_43: - WORD $0x8b49; BYTE $0x0f // movq (%r15), %rcx - LONG $0x000005b8; BYTE $0x00 // movl $5, %eax - LONG $0xfff98148; WORD $0x000f; BYTE $0x00 // cmpq $4095, %rcx - LONG $0xfd3b8e0f; WORD $0xffff // jle LBB23_4, $-709(%rip) - LONG $0x0000dbe9; BYTE $0x00 // jmp LBB23_62, $219(%rip) - -LBB23_44: - LONG $0x24048b49 // movq (%r12), %rax - LONG $0xd0758b48 // movq $-48(%rbp), %rsi - LONG $0x084e8b48 // movq $8(%rsi), %rcx + QUAD $0x00000308ec44c74b; BYTE $0x00 // movq $3, $8(%r12,%r13,8) + LONG $0xfffc4ce9; BYTE $0xff // jmp LBB18_61, $-948(%rip) + +LBB18_57: + QUAD $0x00000002ec04c74b // movq $2, (%r12,%r13,8) + QUAD $0xffffffffc845c748 // movq $-1, $-56(%rbp) + WORD $0x8b4d; BYTE $0x28 // movq (%r8), %r13 + WORD $0x8948; BYTE $0xf7 // movq %rsi, %rdi + WORD $0x894c; BYTE $0xee // movq %r13, %rsi + LONG $0xc8558d48 // leaq $-56(%rbp), %rdx + LONG $0xb84d8b48 // movq $-72(%rbp), %rcx + WORD $0x894c; BYTE $0xc3 // movq %r8, %rbx + LONG $0xffecb3e8; BYTE $0xff // callq _advance_string, $-4941(%rip) + WORD $0x8949; BYTE $0xc7 // movq %rax, %r15 + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0x018c880f; WORD $0x0000 // js LBB18_78, $396(%rip) + WORD $0x894c; BYTE $0x3b // movq %r15, (%rbx) + WORD $0x854d; BYTE $0xed // testq %r13, %r13 + LONG $0x01988e0f; WORD $0x0000 // jle LBB18_79, $408(%rip) + LONG $0x24048b49 // movq (%r12), %rax + LONG $0x0fff3d48; WORD $0x0000 // cmpq $4095, %rax + LONG $0x01648f0f; WORD $0x0000 // jg LBB18_80, $356(%rip) + WORD $0x8949; BYTE $0xd8 // movq %rbx, %r8 + LONG $0x01488d48 // leaq $1(%rax), %rcx + LONG $0x240c8949 // movq %rcx, (%r12) + QUAD $0x00000408c444c749; BYTE $0x00 // movq $4, $8(%r12,%rax,8) + LONG $0xc0758b48 // movq $-64(%rbp), %rsi + QUAD $0x000100002600bb49; WORD $0x0000 // movabsq $4294977024, %r11 + LONG $0xfffbd4e9; BYTE $0xff // jmp LBB18_61, $-1068(%rip) + +LBB18_62: + WORD $0x8b4d; BYTE $0x38 // movq (%r8), %r15 + WORD $0x014c; BYTE $0xff // addq %r15, %rdi + LONG $0xd0458b48 // movq $-48(%rbp), %rax + WORD $0x8b48; BYTE $0x30 // movq (%rax), %rsi + WORD $0x294c; BYTE $0xfe // subq %r15, %rsi + WORD $0x894c; BYTE $0xc3 // movq %r8, %rbx + LONG $0x0005fce8; BYTE $0x00 // callq _do_skip_number, $1532(%rip) + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0x015e880f; WORD $0x0000 // js LBB18_84, $350(%rip) + WORD $0x014c; BYTE $0xf8 // addq %r15, %rax + WORD $0x8948; BYTE $0x03 // movq %rax, (%rbx) + WORD $0x854d; BYTE $0xff // testq %r15, %r15 + WORD $0x8949; BYTE $0xd8 // movq %rbx, %r8 + LONG $0xc0758b48 // movq $-64(%rbp), %rsi + QUAD $0x000100002600bb49; WORD $0x0000 // movabsq $4294977024, %r11 + LONG $0xfb938f0f; WORD $0xffff // jg LBB18_61, $-1133(%rip) + LONG $0x00014ee9; BYTE $0x00 // jmp LBB18_91, $334(%rip) + +LBB18_64: + LONG $0x24048b49 // movq (%r12), %rax + LONG $0x0fff3d48; WORD $0x0000 // cmpq $4095, %rax + LONG $0x00e78f0f; WORD $0x0000 // jg LBB18_80, $231(%rip) + LONG $0x01488d48 // leaq $1(%rax), %rcx + LONG $0x240c8949 // movq %rcx, (%r12) + QUAD $0x00000508c444c749; BYTE $0x00 // movq $5, $8(%r12,%rax,8) + LONG $0xfffb68e9; BYTE $0xff // jmp LBB18_61, $-1176(%rip) + +LBB18_66: + WORD $0x8b49; BYTE $0x00 // movq (%r8), %rax + LONG $0xd04d8b48 // movq $-48(%rbp), %rcx + WORD $0x8b48; BYTE $0x09 // movq (%rcx), %rcx LONG $0xfc518d48 // leaq $-4(%rcx), %rdx WORD $0x3948; BYTE $0xd0 // cmpq %rdx, %rax - LONG $0x00ce870f; WORD $0x0000 // ja LBB23_64, $206(%rip) - WORD $0x8b48; BYTE $0x0e // movq (%rsi), %rcx - WORD $0x148b; BYTE $0x01 // movl (%rcx,%rax), %edx - LONG $0x6c61fa81; WORD $0x6573 // cmpl $1702063201, %edx - LONG $0x0198850f; WORD $0x0000 // jne LBB23_78, $408(%rip) + LONG $0x00e9870f; WORD $0x0000 // ja LBB18_88, $233(%rip) + WORD $0x0c8b; BYTE $0x07 // movl (%rdi,%rax), %ecx + LONG $0x6c61f981; WORD $0x6573 // cmpl $1702063201, %ecx + LONG $0x010a850f; WORD $0x0000 // jne LBB18_92, $266(%rip) LONG $0x04488d48 // leaq $4(%rax), %rcx - LONG $0x240c8949 // movq %rcx, (%r12) + WORD $0x8949; BYTE $0x08 // movq %rcx, (%r8) WORD $0x8548; BYTE $0xc0 // testq %rax, %rax - LONG $0xfd098f0f; WORD $0xffff // jg LBB23_6, $-759(%rip) - LONG $0x00006ae9; BYTE $0x00 // jmp LBB23_52, $106(%rip) + LONG $0xfb328f0f; WORD $0xffff // jg LBB18_61, $-1230(%rip) + LONG $0x0000cde9; BYTE $0x00 // jmp LBB18_83, $205(%rip) -LBB23_47: - LONG $0x24048b49 // movq (%r12), %rax - LONG $0xd0758b48 // movq $-48(%rbp), %rsi - LONG $0x084e8b48 // movq $8(%rsi), %rcx +LBB18_69: + WORD $0x8b49; BYTE $0x00 // movq (%r8), %rax + LONG $0xd04d8b48 // movq $-48(%rbp), %rcx + WORD $0x8b48; BYTE $0x09 // movq (%rcx), %rcx LONG $0xfd518d48 // leaq $-3(%rcx), %rdx WORD $0x3948; BYTE $0xd0 // cmpq %rdx, %rax - LONG $0x008d870f; WORD $0x0000 // ja LBB23_64, $141(%rip) - WORD $0x8b48; BYTE $0x0e // movq (%rsi), %rcx - QUAD $0x6c6c756eff017c81 // cmpl $1819047278, $-1(%rcx,%rax) - LONG $0x002f840f; WORD $0x0000 // je LBB23_51, $47(%rip) - LONG $0x0000a5e9; BYTE $0x00 // jmp LBB23_69, $165(%rip) - -LBB23_49: - LONG $0x24048b49 // movq (%r12), %rax - LONG $0xd0758b48 // movq $-48(%rbp), %rsi - LONG $0x084e8b48 // movq $8(%rsi), %rcx + LONG $0x00ae870f; WORD $0x0000 // ja LBB18_88, $174(%rip) + QUAD $0x6c6c756eff077c81 // cmpl $1819047278, $-1(%rdi,%rax) + LONG $0xfaef840f; WORD $0xffff // je LBB18_2, $-1297(%rip) + LONG $0x00011de9; BYTE $0x00 // jmp LBB18_97, $285(%rip) + +LBB18_71: + WORD $0x8b49; BYTE $0x00 // movq (%r8), %rax + LONG $0xd04d8b48 // movq $-48(%rbp), %rcx + WORD $0x8b48; BYTE $0x09 // movq (%rcx), %rcx LONG $0xfd518d48 // leaq $-3(%rcx), %rdx WORD $0x3948; BYTE $0xd0 // cmpq %rdx, %rax - LONG $0x005e870f; WORD $0x0000 // ja LBB23_64, $94(%rip) - WORD $0x8b48; BYTE $0x0e // movq (%rsi), %rcx - QUAD $0x65757274ff017c81 // cmpl $1702195828, $-1(%rcx,%rax) - LONG $0x00ce850f; WORD $0x0000 // jne LBB23_73, $206(%rip) - -LBB23_51: - LONG $0x03488d48 // leaq $3(%rax), %rcx - LONG $0x240c8949 // movq %rcx, (%r12) - WORD $0x8548; BYTE $0xc0 // testq %rax, %rax - LONG $0xfc9a8f0f; WORD $0xffff // jg LBB23_6, $-870(%rip) - -LBB23_52: - WORD $0xff48; BYTE $0xc8 // decq %rax - -LBB23_54: - WORD $0x8949; BYTE $0xc5 // movq %rax, %r13 - LONG $0x000007e9; BYTE $0x00 // jmp LBB23_55, $7(%rip) - -LBB23_2: - LONG $0xffc5c749; WORD $0xffff; BYTE $0xff // movq $-1, %r13 + LONG $0x0084870f; WORD $0x0000 // ja LBB18_88, $132(%rip) + QUAD $0x65757274ff077c81 // cmpl $1702195828, $-1(%rdi,%rax) + LONG $0xfac5840f; WORD $0xffff // je LBB18_2, $-1339(%rip) + LONG $0x000142e9; BYTE $0x00 // jmp LBB18_101, $322(%rip) + +LBB18_73: + LONG $0x24048b49 // movq (%r12), %rax + LONG $0x0fff3d48; WORD $0x0000 // cmpq $4095, %rax + LONG $0x00328f0f; WORD $0x0000 // jg LBB18_80, $50(%rip) + LONG $0x01488d48 // leaq $1(%rax), %rcx + LONG $0x240c8949 // movq %rcx, (%r12) + QUAD $0x00000608c444c749; BYTE $0x00 // movq $6, $8(%r12,%rax,8) + LONG $0xfffab3e9; BYTE $0xff // jmp LBB18_61, $-1357(%rip) + +LBB18_75: + WORD $0x8949; BYTE $0x18 // movq %rbx, (%r8) + +LBB18_76: + LONG $0xffc7c749; WORD $0xffff; BYTE $0xff // movq $-1, %r15 -LBB23_55: - WORD $0x894c; BYTE $0xe8 // movq %r13, %rax +LBB18_77: + WORD $0x894c; BYTE $0xf8 // movq %r15, %rax LONG $0x28c48348 // addq $40, %rsp BYTE $0x5b // popq %rbx WORD $0x5c41 // popq %r12 @@ -6045,245 +5699,260 @@ LBB23_55: BYTE $0x5d // popq %rbp BYTE $0xc3 // retq -LBB23_58: - LONG $0xfec5c749; WORD $0xffff; BYTE $0xff // movq $-2, %r13 - LONG $0xffffe2e9; BYTE $0xff // jmp LBB23_55, $-30(%rip) +LBB18_80: + LONG $0xf9c7c749; WORD $0xffff; BYTE $0xff // movq $-7, %r15 + LONG $0xffffe2e9; BYTE $0xff // jmp LBB18_77, $-30(%rip) -LBB23_62: - LONG $0xf9c5c749; WORD $0xffff; BYTE $0xff // movq $-7, %r13 - LONG $0xffffd6e9; BYTE $0xff // jmp LBB23_55, $-42(%rip) +LBB18_78: + LONG $0xffff8349 // cmpq $-1, %r15 + LONG $0xc8458d48 // leaq $-56(%rbp), %rax + LONG $0x45440f48; BYTE $0xd0 // cmoveq $-48(%rbp), %rax + WORD $0x8b48; BYTE $0x00 // movq (%rax), %rax + WORD $0x8948; BYTE $0x03 // movq %rax, (%rbx) + LONG $0xffffcae9; BYTE $0xff // jmp LBB18_77, $-54(%rip) -LBB23_64: - LONG $0x240c8949 // movq %rcx, (%r12) - LONG $0xffc5c749; WORD $0xffff; BYTE $0xff // movq $-1, %r13 - LONG $0xffffc6e9; BYTE $0xff // jmp LBB23_55, $-58(%rip) +LBB18_79: + WORD $0xff49; BYTE $0xcd // decq %r13 + WORD $0x894d; BYTE $0xef // movq %r13, %r15 + LONG $0xffffbfe9; BYTE $0xff // jmp LBB18_77, $-65(%rip) -LBB23_66: - WORD $0xf748; BYTE $0xd0 // notq %rax - WORD $0x0149; BYTE $0xc5 // addq %rax, %r13 - LONG $0x242c894d // movq %r13, (%r12) - LONG $0xfec5c749; WORD $0xffff; BYTE $0xff // movq $-2, %r13 - LONG $0xffffb0e9; BYTE $0xff // jmp LBB23_55, $-80(%rip) +LBB18_88: + WORD $0x8949; BYTE $0x08 // movq %rcx, (%r8) + LONG $0xffffb7e9; BYTE $0xff // jmp LBB18_77, $-73(%rip) -LBB23_68: - WORD $0xff49; BYTE $0xcd // decq %r13 - LONG $0xffffa8e9; BYTE $0xff // jmp LBB23_55, $-88(%rip) +LBB18_83: + WORD $0xff48; BYTE $0xc8 // decq %rax + WORD $0x8949; BYTE $0xc7 // movq %rax, %r15 + LONG $0xfffface9; BYTE $0xff // jmp LBB18_77, $-84(%rip) -LBB23_69: - LONG $0xff508d48 // leaq $-1(%rax), %rdx - LONG $0x24148949 // movq %rdx, (%r12) - LONG $0xfec5c749; WORD $0xffff; BYTE $0xff // movq $-2, %r13 - LONG $0xff017c80; BYTE $0x6e // cmpb $110, $-1(%rcx,%rax) - LONG $0xff8e850f; WORD $0xffff // jne LBB23_55, $-114(%rip) - LONG $0x24048949 // movq %rax, (%r12) - LONG $0x75013c80 // cmpb $117, (%rcx,%rax) - LONG $0xff80850f; WORD $0xffff // jne LBB23_55, $-128(%rip) - LONG $0x01508d48 // leaq $1(%rax), %rdx - LONG $0x24148949 // movq %rdx, (%r12) - LONG $0x01017c80; BYTE $0x6c // cmpb $108, $1(%rcx,%rax) - LONG $0xff6d850f; WORD $0xffff // jne LBB23_55, $-147(%rip) - LONG $0x02508d48 // leaq $2(%rax), %rdx - LONG $0x24148949 // movq %rdx, (%r12) - LONG $0x02017c80; BYTE $0x6c // cmpb $108, $2(%rcx,%rax) - LONG $0xff5a850f; WORD $0xffff // jne LBB23_55, $-166(%rip) - LONG $0x00004ee9; BYTE $0x00 // jmp LBB23_77, $78(%rip) - -LBB23_73: - LONG $0xff508d48 // leaq $-1(%rax), %rdx - LONG $0x24148949 // movq %rdx, (%r12) - LONG $0xfec5c749; WORD $0xffff; BYTE $0xff // movq $-2, %r13 - LONG $0xff017c80; BYTE $0x74 // cmpb $116, $-1(%rcx,%rax) - LONG $0xff3b850f; WORD $0xffff // jne LBB23_55, $-197(%rip) - LONG $0x24048949 // movq %rax, (%r12) - LONG $0x72013c80 // cmpb $114, (%rcx,%rax) - LONG $0xff2d850f; WORD $0xffff // jne LBB23_55, $-211(%rip) - LONG $0x01508d48 // leaq $1(%rax), %rdx - LONG $0x24148949 // movq %rdx, (%r12) - LONG $0x01017c80; BYTE $0x75 // cmpb $117, $1(%rcx,%rax) - LONG $0xff1a850f; WORD $0xffff // jne LBB23_55, $-230(%rip) - LONG $0x02508d48 // leaq $2(%rax), %rdx - LONG $0x24148949 // movq %rdx, (%r12) - LONG $0x02017c80; BYTE $0x65 // cmpb $101, $2(%rcx,%rax) - LONG $0xff07850f; WORD $0xffff // jne LBB23_55, $-249(%rip) - -LBB23_77: - LONG $0x03c08348 // addq $3, %rax - LONG $0x24048949 // movq %rax, (%r12) - LONG $0xfffefae9; BYTE $0xff // jmp LBB23_55, $-262(%rip) - -LBB23_78: - LONG $0xfec5c749; WORD $0xffff; BYTE $0xff // movq $-2, %r13 - WORD $0xfa80; BYTE $0x61 // cmpb $97, %dl - LONG $0xfeea850f; WORD $0xffff // jne LBB23_55, $-278(%rip) - LONG $0x01508d48 // leaq $1(%rax), %rdx - LONG $0x24148949 // movq %rdx, (%r12) - LONG $0x01017c80; BYTE $0x6c // cmpb $108, $1(%rcx,%rax) - LONG $0xfed7850f; WORD $0xffff // jne LBB23_55, $-297(%rip) - LONG $0x02508d48 // leaq $2(%rax), %rdx - LONG $0x24148949 // movq %rdx, (%r12) - LONG $0x02017c80; BYTE $0x73 // cmpb $115, $2(%rcx,%rax) - LONG $0xfec4850f; WORD $0xffff // jne LBB23_55, $-316(%rip) - LONG $0x03508d48 // leaq $3(%rax), %rdx - LONG $0x24148949 // movq %rdx, (%r12) - LONG $0x03017c80; BYTE $0x65 // cmpb $101, $3(%rcx,%rax) - LONG $0xfeb1850f; WORD $0xffff // jne LBB23_55, $-335(%rip) +LBB18_84: + WORD $0xf748; BYTE $0xd0 // notq %rax + WORD $0x0149; BYTE $0xc7 // addq %rax, %r15 + WORD $0x894c; BYTE $0x3b // movq %r15, (%rbx) + +LBB18_85: + LONG $0xfec7c749; WORD $0xffff; BYTE $0xff // movq $-2, %r15 + LONG $0xffff97e9; BYTE $0xff // jmp LBB18_77, $-105(%rip) + +LBB18_91: + WORD $0xff49; BYTE $0xcf // decq %r15 + LONG $0xffff8fe9; BYTE $0xff // jmp LBB18_77, $-113(%rip) + +LBB18_92: + LONG $0xfec7c749; WORD $0xffff; BYTE $0xff // movq $-2, %r15 + WORD $0xf980; BYTE $0x61 // cmpb $97, %cl + LONG $0xff7f850f; WORD $0xffff // jne LBB18_77, $-129(%rip) + LONG $0x01488d48 // leaq $1(%rax), %rcx + WORD $0x8949; BYTE $0x08 // movq %rcx, (%r8) + LONG $0x01077c80; BYTE $0x6c // cmpb $108, $1(%rdi,%rax) + LONG $0xff6d850f; WORD $0xffff // jne LBB18_77, $-147(%rip) + LONG $0x02488d48 // leaq $2(%rax), %rcx + WORD $0x8949; BYTE $0x08 // movq %rcx, (%r8) + LONG $0x02077c80; BYTE $0x73 // cmpb $115, $2(%rdi,%rax) + LONG $0xff5b850f; WORD $0xffff // jne LBB18_77, $-165(%rip) + LONG $0x03488d48 // leaq $3(%rax), %rcx + WORD $0x8949; BYTE $0x08 // movq %rcx, (%r8) + LONG $0x03077c80; BYTE $0x65 // cmpb $101, $3(%rdi,%rax) + LONG $0xff49850f; WORD $0xffff // jne LBB18_77, $-183(%rip) LONG $0x04c08348 // addq $4, %rax - LONG $0x24048949 // movq %rax, (%r12) - LONG $0xfffea4e9; BYTE $0xff // jmp LBB23_55, $-348(%rip) - BYTE $0x90 // .p2align 2, 0x90 - - // .set L23_0_set_12, LBB23_12-LJTI23_0 - // .set L23_0_set_15, LBB23_15-LJTI23_0 - // .set L23_0_set_18, LBB23_18-LJTI23_0 - // .set L23_0_set_22, LBB23_22-LJTI23_0 - // .set L23_0_set_24, LBB23_24-LJTI23_0 - // .set L23_0_set_28, LBB23_28-LJTI23_0 -LJTI23_0: - LONG $0xfffffb8e // .long L23_0_set_12 - LONG $0xfffffbbd // .long L23_0_set_15 - LONG $0xfffffbe6 // .long L23_0_set_18 - LONG $0xfffffc22 // .long L23_0_set_22 - LONG $0xfffffc31 // .long L23_0_set_24 - LONG $0xfffffcc4 // .long L23_0_set_28 - - // .set L23_1_set_55, LBB23_55-LJTI23_1 - // .set L23_1_set_54, LBB23_54-LJTI23_1 - // .set L23_1_set_40, LBB23_40-LJTI23_1 - // .set L23_1_set_41, LBB23_41-LJTI23_1 - // .set L23_1_set_27, LBB23_27-LJTI23_1 - // .set L23_1_set_43, LBB23_43-LJTI23_1 - // .set L23_1_set_44, LBB23_44-LJTI23_1 - // .set L23_1_set_47, LBB23_47-LJTI23_1 - // .set L23_1_set_49, LBB23_49-LJTI23_1 - // .set L23_1_set_3, LBB23_3-LJTI23_1 -LJTI23_1: - LONG $0xfffffe8b // .long L23_1_set_55 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffd6f // .long L23_1_set_40 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffd7c // .long L23_1_set_41 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffc52 // .long L23_1_set_27 - LONG $0xfffffc52 // .long L23_1_set_27 - LONG $0xfffffc52 // .long L23_1_set_27 - LONG $0xfffffc52 // .long L23_1_set_27 - LONG $0xfffffc52 // .long L23_1_set_27 - LONG $0xfffffc52 // .long L23_1_set_27 - LONG $0xfffffc52 // .long L23_1_set_27 - LONG $0xfffffc52 // .long L23_1_set_27 - LONG $0xfffffc52 // .long L23_1_set_27 - LONG $0xfffffc52 // .long L23_1_set_27 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffdb4 // .long L23_1_set_43 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffdce // .long L23_1_set_44 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe0f // .long L23_1_set_47 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe3e // .long L23_1_set_49 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffe7c // .long L23_1_set_54 - LONG $0xfffffaed // .long L23_1_set_3 - LONG $0x00000000 // .p2align 4, 0x00 + WORD $0x8949; BYTE $0x00 // movq %rax, (%r8) + LONG $0xffff3de9; BYTE $0xff // jmp LBB18_77, $-195(%rip) + +LBB18_97: + LONG $0xff488d48 // leaq $-1(%rax), %rcx + WORD $0x8949; BYTE $0x08 // movq %rcx, (%r8) + LONG $0xfec7c749; WORD $0xffff; BYTE $0xff // movq $-2, %r15 + LONG $0xff077c80; BYTE $0x6e // cmpb $110, $-1(%rdi,%rax) + LONG $0xff24850f; WORD $0xffff // jne LBB18_77, $-220(%rip) + WORD $0x8949; BYTE $0x00 // movq %rax, (%r8) + LONG $0x75073c80 // cmpb $117, (%rdi,%rax) + LONG $0xff17850f; WORD $0xffff // jne LBB18_77, $-233(%rip) + LONG $0x01488d48 // leaq $1(%rax), %rcx + WORD $0x8949; BYTE $0x08 // movq %rcx, (%r8) + LONG $0x01077c80; BYTE $0x6c // cmpb $108, $1(%rdi,%rax) + LONG $0xff05850f; WORD $0xffff // jne LBB18_77, $-251(%rip) + LONG $0x02488d48 // leaq $2(%rax), %rcx + WORD $0x8949; BYTE $0x08 // movq %rcx, (%r8) + LONG $0x02077c80; BYTE $0x6c // cmpb $108, $2(%rdi,%rax) + LONG $0xfef3850f; WORD $0xffff // jne LBB18_77, $-269(%rip) + LONG $0x00004ae9; BYTE $0x00 // jmp LBB18_105, $74(%rip) + +LBB18_101: + LONG $0xff488d48 // leaq $-1(%rax), %rcx + WORD $0x8949; BYTE $0x08 // movq %rcx, (%r8) + LONG $0xfec7c749; WORD $0xffff; BYTE $0xff // movq $-2, %r15 + LONG $0xff077c80; BYTE $0x74 // cmpb $116, $-1(%rdi,%rax) + LONG $0xfed5850f; WORD $0xffff // jne LBB18_77, $-299(%rip) + WORD $0x8949; BYTE $0x00 // movq %rax, (%r8) + LONG $0x72073c80 // cmpb $114, (%rdi,%rax) + LONG $0xfec8850f; WORD $0xffff // jne LBB18_77, $-312(%rip) + LONG $0x01488d48 // leaq $1(%rax), %rcx + WORD $0x8949; BYTE $0x08 // movq %rcx, (%r8) + LONG $0x01077c80; BYTE $0x75 // cmpb $117, $1(%rdi,%rax) + LONG $0xfeb6850f; WORD $0xffff // jne LBB18_77, $-330(%rip) + LONG $0x02488d48 // leaq $2(%rax), %rcx + WORD $0x8949; BYTE $0x08 // movq %rcx, (%r8) + LONG $0x02077c80; BYTE $0x65 // cmpb $101, $2(%rdi,%rax) + LONG $0xfea4850f; WORD $0xffff // jne LBB18_77, $-348(%rip) + +LBB18_105: + LONG $0x03c08348 // addq $3, %rax + WORD $0x8949; BYTE $0x00 // movq %rax, (%r8) + LONG $0xfffe98e9; BYTE $0xff // jmp LBB18_77, $-360(%rip) + BYTE $0x90 // .p2align 2, 0x90 + + // .set L18_0_set_32, LBB18_32-LJTI18_0 + // .set L18_0_set_36, LBB18_36-LJTI18_0 + // .set L18_0_set_39, LBB18_39-LJTI18_0 + // .set L18_0_set_43, LBB18_43-LJTI18_0 + // .set L18_0_set_45, LBB18_45-LJTI18_0 + // .set L18_0_set_47, LBB18_47-LJTI18_0 +LJTI18_0: + LONG $0xfffffb0c // .long L18_0_set_32 + LONG $0xfffffb45 // .long L18_0_set_36 + LONG $0xfffffb6c // .long L18_0_set_39 + LONG $0xfffffbcc // .long L18_0_set_43 + LONG $0xfffffbe2 // .long L18_0_set_45 + LONG $0xfffffc00 // .long L18_0_set_47 + + // .set L18_1_set_77, LBB18_77-LJTI18_1 + // .set L18_1_set_85, LBB18_85-LJTI18_1 + // .set L18_1_set_41, LBB18_41-LJTI18_1 + // .set L18_1_set_62, LBB18_62-LJTI18_1 + // .set L18_1_set_52, LBB18_52-LJTI18_1 + // .set L18_1_set_64, LBB18_64-LJTI18_1 + // .set L18_1_set_66, LBB18_66-LJTI18_1 + // .set L18_1_set_69, LBB18_69-LJTI18_1 + // .set L18_1_set_71, LBB18_71-LJTI18_1 + // .set L18_1_set_73, LBB18_73-LJTI18_1 +LJTI18_1: + LONG $0xfffffe7f // .long L18_1_set_77 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffb65 // .long L18_1_set_41 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffd54 // .long L18_1_set_62 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffc32 // .long L18_1_set_52 + LONG $0xfffffc32 // .long L18_1_set_52 + LONG $0xfffffc32 // .long L18_1_set_52 + LONG $0xfffffc32 // .long L18_1_set_52 + LONG $0xfffffc32 // .long L18_1_set_52 + LONG $0xfffffc32 // .long L18_1_set_52 + LONG $0xfffffc32 // .long L18_1_set_52 + LONG $0xfffffc32 // .long L18_1_set_52 + LONG $0xfffffc32 // .long L18_1_set_52 + LONG $0xfffffc32 // .long L18_1_set_52 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffd9a // .long L18_1_set_64 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffdc0 // .long L18_1_set_66 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffdfb // .long L18_1_set_69 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffe25 // .long L18_1_set_71 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffedc // .long L18_1_set_85 + LONG $0xfffffe4f // .long L18_1_set_73 + QUAD $0x0000000000000000 // .p2align 4, 0x00 -LCPI24_0: +LCPI19_0: QUAD $0x0000000000000001 // .quad 1 QUAD $0x0000000000000006 // .quad 6 @@ -6294,43 +5963,53 @@ _skip_object: WORD $0x8948; BYTE $0xd0 // movq %rdx, %rax WORD $0x8948; BYTE $0xf2 // movq %rsi, %rdx WORD $0x8948; BYTE $0xfe // movq %rdi, %rsi - LONG $0xdc05280f; WORD $0xffff; BYTE $0xff // movaps $-36(%rip), %xmm0 /* LCPI24_0(%rip) */ + LONG $0xdc05280f; WORD $0xffff; BYTE $0xff // movaps $-36(%rip), %xmm0 /* LCPI19_0(%rip) */ WORD $0x110f; BYTE $0x00 // movups %xmm0, (%rax) WORD $0x8948; BYTE $0xc7 // movq %rax, %rdi BYTE $0x5d // popq %rbp - LONG $0xfff890e9; BYTE $0xff // jmp _fsm_exec, $-1904(%rip) + LONG $0xfff6a0e9; BYTE $0xff // jmp _fsm_exec, $-2400(%rip) // .p2align 4, 0x90 _skip_string: BYTE $0x55 // pushq %rbp WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5741 // pushq %r15 WORD $0x5641 // pushq %r14 + WORD $0x5441 // pushq %r12 BYTE $0x53 // pushq %rbx LONG $0x10ec8348 // subq $16, %rsp WORD $0x8948; BYTE $0xd1 // movq %rdx, %rcx WORD $0x8949; BYTE $0xf6 // movq %rsi, %r14 + WORD $0x8949; BYTE $0xff // movq %rdi, %r15 + QUAD $0xffffffffd845c748 // movq $-1, $-40(%rbp) WORD $0x8b48; BYTE $0x1e // movq (%rsi), %rbx - LONG $0xe8558d48 // leaq $-24(%rbp), %rdx + LONG $0xd8658d4c // leaq $-40(%rbp), %r12 WORD $0x8948; BYTE $0xde // movq %rbx, %rsi - LONG $0xffea40e8; BYTE $0xff // callq _advance_string, $-5568(%rip) + WORD $0x894c; BYTE $0xe2 // movq %r12, %rdx + LONG $0xffe75ee8; BYTE $0xff // callq _advance_string, $-6306(%rip) WORD $0x8548; BYTE $0xc0 // testq %rax, %rax - LONG $0x0009890f; WORD $0x0000 // jns LBB25_1, $9(%rip) - LONG $0xe84d8b48 // movq $-24(%rbp), %rcx - LONG $0x000009e9; BYTE $0x00 // jmp LBB25_3, $9(%rip) - -LBB25_1: - WORD $0xff48; BYTE $0xcb // decq %rbx - WORD $0x8948; BYTE $0xc1 // movq %rax, %rcx - WORD $0x8948; BYTE $0xd8 // movq %rbx, %rax + LONG $0x000e880f; WORD $0x0000 // js LBB20_1, $14(%rip) + WORD $0xff48; BYTE $0xcb // decq %rbx + WORD $0x8948; BYTE $0xc1 // movq %rax, %rcx + WORD $0x8948; BYTE $0xd8 // movq %rbx, %rax + LONG $0x000010e9; BYTE $0x00 // jmp LBB20_3, $16(%rip) -LBB25_3: - WORD $0x8949; BYTE $0x0e // movq %rcx, (%r14) - LONG $0x10c48348 // addq $16, %rsp - BYTE $0x5b // popq %rbx - WORD $0x5e41 // popq %r14 - BYTE $0x5d // popq %rbp - BYTE $0xc3 // retq - QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90 +LBB20_1: + LONG $0x08c78349 // addq $8, %r15 + LONG $0xfff88348 // cmpq $-1, %rax + LONG $0xe7440f4d // cmoveq %r15, %r12 + LONG $0x240c8b49 // movq (%r12), %rcx + +LBB20_3: + WORD $0x8949; BYTE $0x0e // movq %rcx, (%r14) + LONG $0x10c48348 // addq $16, %rsp + BYTE $0x5b // popq %rbx + WORD $0x5c41 // popq %r12 + WORD $0x5e41 // popq %r14 + WORD $0x5f41 // popq %r15 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 _skip_negative: BYTE $0x55 // pushq %rbp @@ -6346,19 +6025,19 @@ _skip_negative: WORD $0x8948; BYTE $0xc7 // movq %rax, %rdi LONG $0x0000aee8; BYTE $0x00 // callq _do_skip_number, $174(%rip) WORD $0x8548; BYTE $0xc0 // testq %rax, %rax - LONG $0x000e880f; WORD $0x0000 // js LBB26_1, $14(%rip) + LONG $0x000e880f; WORD $0x0000 // js LBB21_1, $14(%rip) WORD $0x0148; BYTE $0xd8 // addq %rbx, %rax WORD $0x8949; BYTE $0x06 // movq %rax, (%r14) WORD $0xff48; BYTE $0xcb // decq %rbx - LONG $0x000010e9; BYTE $0x00 // jmp LBB26_3, $16(%rip) + LONG $0x000010e9; BYTE $0x00 // jmp LBB21_3, $16(%rip) -LBB26_1: +LBB21_1: WORD $0xf748; BYTE $0xd0 // notq %rax WORD $0x0148; BYTE $0xc3 // addq %rax, %rbx WORD $0x8949; BYTE $0x1e // movq %rbx, (%r14) LONG $0xfec3c748; WORD $0xffff; BYTE $0xff // movq $-2, %rbx -LBB26_3: +LBB21_3: WORD $0x8948; BYTE $0xd8 // movq %rbx, %rax BYTE $0x5b // popq %rbx WORD $0x5e41 // popq %r14 @@ -6366,25 +6045,25 @@ LBB26_3: BYTE $0xc3 // retq QUAD $0x0000000000000000; LONG $0x00000000; WORD $0x0000; BYTE $0x00 // .p2align 4, 0x00 -LCPI27_0: - QUAD $0x2b2b2b2b2b2b2b2b; QUAD $0x2b2b2b2b2b2b2b2b // .space 16, '++++++++++++++++' +LCPI22_0: + QUAD $0x2f2f2f2f2f2f2f2f; QUAD $0x2f2f2f2f2f2f2f2f // .space 16, '////////////////' -LCPI27_1: - QUAD $0x2d2d2d2d2d2d2d2d; QUAD $0x2d2d2d2d2d2d2d2d // .space 16, '----------------' +LCPI22_1: + QUAD $0x3a3a3a3a3a3a3a3a; QUAD $0x3a3a3a3a3a3a3a3a // .space 16, '::::::::::::::::' -LCPI27_2: - QUAD $0xd0d0d0d0d0d0d0d0; QUAD $0xd0d0d0d0d0d0d0d0 // .space 16, '\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0' +LCPI22_2: + QUAD $0x2b2b2b2b2b2b2b2b; QUAD $0x2b2b2b2b2b2b2b2b // .space 16, '++++++++++++++++' -LCPI27_3: - QUAD $0x0909090909090909; QUAD $0x0909090909090909 // .space 16, '\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t' +LCPI22_3: + QUAD $0x2d2d2d2d2d2d2d2d; QUAD $0x2d2d2d2d2d2d2d2d // .space 16, '----------------' -LCPI27_4: +LCPI22_4: QUAD $0xdfdfdfdfdfdfdfdf; QUAD $0xdfdfdfdfdfdfdfdf // .space 16, '\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf' -LCPI27_5: +LCPI22_5: QUAD $0x2e2e2e2e2e2e2e2e; QUAD $0x2e2e2e2e2e2e2e2e // .space 16, '................' -LCPI27_6: +LCPI22_6: QUAD $0x4545454545454545; QUAD $0x4545454545454545 // .space 16, 'EEEEEEEEEEEEEEEE' // .p2align 4, 0x90 @@ -6395,304 +6074,339 @@ _do_skip_number: WORD $0x5641 // pushq %r14 BYTE $0x53 // pushq %rbx WORD $0x8548; BYTE $0xf6 // testq %rsi, %rsi - LONG $0x0255840f; WORD $0x0000 // je LBB27_1, $597(%rip) + LONG $0x0278840f; WORD $0x0000 // je LBB22_34, $632(%rip) WORD $0x3f80; BYTE $0x30 // cmpb $48, (%rdi) - LONG $0x0033850f; WORD $0x0000 // jne LBB27_6, $51(%rip) - LONG $0x000001b8; BYTE $0x00 // movl $1, %eax + LONG $0x0033850f; WORD $0x0000 // jne LBB22_5, $51(%rip) + LONG $0x000001ba; BYTE $0x00 // movl $1, %edx LONG $0x01fe8348 // cmpq $1, %rsi - LONG $0x02d8840f; WORD $0x0000 // je LBB27_55, $728(%rip) - LONG $0x014fb60f // movzbl $1(%rdi), %ecx - WORD $0xc183; BYTE $0xd2 // addl $-46, %ecx - WORD $0xf983; BYTE $0x37 // cmpl $55, %ecx - LONG $0x02c8870f; WORD $0x0000 // ja LBB27_55, $712(%rip) - QUAD $0x000000800001ba48; WORD $0x0080 // movabsq $36028797027352577, %rdx - LONG $0xcaa30f48 // btq %rcx, %rdx - LONG $0x02b4830f; WORD $0x0000 // jae LBB27_55, $692(%rip) - -LBB27_6: - LONG $0x10fe8348 // cmpq $16, %rsi - LONG $0x0313820f; WORD $0x0000 // jb LBB27_7, $787(%rip) - LONG $0xffc2c749; WORD $0xffff; BYTE $0xff // movq $-1, %r10 - WORD $0xc031 // xorl %eax, %eax - QUAD $0xffff26056f0f4466; BYTE $0xff // movdqa $-218(%rip), %xmm8 /* LCPI27_0(%rip) */ - QUAD $0xffff2d0d6f0f4466; BYTE $0xff // movdqa $-211(%rip), %xmm9 /* LCPI27_1(%rip) */ - QUAD $0xffff34156f0f4466; BYTE $0xff // movdqa $-204(%rip), %xmm10 /* LCPI27_2(%rip) */ - QUAD $0xffffff3c1d6f0f66 // movdqa $-196(%rip), %xmm3 /* LCPI27_3(%rip) */ - QUAD $0xffffff44256f0f66 // movdqa $-188(%rip), %xmm4 /* LCPI27_4(%rip) */ - QUAD $0xffffff4c2d6f0f66 // movdqa $-180(%rip), %xmm5 /* LCPI27_5(%rip) */ - QUAD $0xffffff54356f0f66 // movdqa $-172(%rip), %xmm6 /* LCPI27_6(%rip) */ - LONG $0xffc1c749; WORD $0xffff; BYTE $0xff // movq $-1, %r9 - LONG $0xffc0c749; WORD $0xffff; BYTE $0xff // movq $-1, %r8 - WORD $0x8949; BYTE $0xf6 // movq %rsi, %r14 - WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + LONG $0x0331840f; WORD $0x0000 // je LBB22_52, $817(%rip) + WORD $0x478a; BYTE $0x01 // movb $1(%rdi), %al + WORD $0xd204 // addb $-46, %al + WORD $0x373c // cmpb $55, %al + LONG $0x0324870f; WORD $0x0000 // ja LBB22_52, $804(%rip) + WORD $0xb60f; BYTE $0xc0 // movzbl %al, %eax + QUAD $0x000000800001b948; WORD $0x0080 // movabsq $36028797027352577, %rcx + LONG $0xc1a30f48 // btq %rax, %rcx + LONG $0x030d830f; WORD $0x0000 // jae LBB22_52, $781(%rip) + +LBB22_5: + LONG $0x10fe8348 // cmpq $16, %rsi + LONG $0x032d820f; WORD $0x0000 // jb LBB22_57, $813(%rip) + LONG $0xffc1c749; WORD $0xffff; BYTE $0xff // movq $-1, %r9 + QUAD $0xffff28056f0f4466; BYTE $0xff // movdqa $-216(%rip), %xmm8 /* LCPI22_0(%rip) */ + QUAD $0xffff2f156f0f4466; BYTE $0xff // movdqa $-209(%rip), %xmm10 /* LCPI22_1(%rip) */ + QUAD $0xffff360d6f0f4466; BYTE $0xff // movdqa $-202(%rip), %xmm9 /* LCPI22_2(%rip) */ + QUAD $0xffffff3e1d6f0f66 // movdqa $-194(%rip), %xmm3 /* LCPI22_3(%rip) */ + QUAD $0xffffff46256f0f66 // movdqa $-186(%rip), %xmm4 /* LCPI22_4(%rip) */ + QUAD $0xffffff4e2d6f0f66 // movdqa $-178(%rip), %xmm5 /* LCPI22_5(%rip) */ + QUAD $0xffffff56356f0f66 // movdqa $-170(%rip), %xmm6 /* LCPI22_6(%rip) */ + LONG $0xffffbb41; WORD $0xffff // movl $4294967295, %r11d + LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax + LONG $0xffc0c749; WORD $0xffff; BYTE $0xff // movq $-1, %r8 + WORD $0x8949; BYTE $0xfa // movq %rdi, %r10 + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 -LBB27_9: - LONG $0x3c6f0ff3; BYTE $0x07 // movdqu (%rdi,%rax), %xmm7 +LBB22_7: + LONG $0x6f0f41f3; BYTE $0x3a // movdqu (%r10), %xmm7 LONG $0xc76f0f66 // movdqa %xmm7, %xmm0 - LONG $0x740f4166; BYTE $0xc0 // pcmpeqb %xmm8, %xmm0 - LONG $0xcf6f0f66 // movdqa %xmm7, %xmm1 - LONG $0x740f4166; BYTE $0xc9 // pcmpeqb %xmm9, %xmm1 - LONG $0xc8eb0f66 // por %xmm0, %xmm1 + LONG $0x640f4166; BYTE $0xc0 // pcmpgtb %xmm8, %xmm0 + LONG $0x6f0f4166; BYTE $0xca // movdqa %xmm10, %xmm1 + LONG $0xcf640f66 // pcmpgtb %xmm7, %xmm1 + LONG $0xc8db0f66 // pand %xmm0, %xmm1 LONG $0xc76f0f66 // movdqa %xmm7, %xmm0 - LONG $0xfc0f4166; BYTE $0xc2 // paddb %xmm10, %xmm0 - LONG $0xd06f0f66 // movdqa %xmm0, %xmm2 - LONG $0xd3da0f66 // pminub %xmm3, %xmm2 - LONG $0xd0740f66 // pcmpeqb %xmm0, %xmm2 + LONG $0x740f4166; BYTE $0xc1 // pcmpeqb %xmm9, %xmm0 + LONG $0xd76f0f66 // movdqa %xmm7, %xmm2 + LONG $0xd3740f66 // pcmpeqb %xmm3, %xmm2 + LONG $0xd0eb0f66 // por %xmm0, %xmm2 LONG $0xc76f0f66 // movdqa %xmm7, %xmm0 LONG $0xc4db0f66 // pand %xmm4, %xmm0 LONG $0xc6740f66 // pcmpeqb %xmm6, %xmm0 LONG $0xfd740f66 // pcmpeqb %xmm5, %xmm7 - LONG $0xd7d70f66 // pmovmskb %xmm7, %edx LONG $0xd70f4466; BYTE $0xf8 // pmovmskb %xmm0, %r15d - LONG $0xd70f4466; BYTE $0xd9 // pmovmskb %xmm1, %r11d - LONG $0xf8eb0f66 // por %xmm0, %xmm7 - LONG $0xf9eb0f66 // por %xmm1, %xmm7 - LONG $0xfaeb0f66 // por %xmm2, %xmm7 - LONG $0xcfd70f66 // pmovmskb %xmm7, %ecx - WORD $0xd1f7 // notl %ecx - WORD $0xbc0f; BYTE $0xc9 // bsfl %ecx, %ecx + LONG $0xc7eb0f66 // por %xmm7, %xmm0 + LONG $0xcaeb0f66 // por %xmm2, %xmm1 + LONG $0xc8eb0f66 // por %xmm0, %xmm1 + LONG $0xd7d70f66 // pmovmskb %xmm7, %edx + LONG $0xd70f4466; BYTE $0xf2 // pmovmskb %xmm2, %r14d + LONG $0xc9d70f66 // pmovmskb %xmm1, %ecx + WORD $0x314c; BYTE $0xd9 // xorq %r11, %rcx + LONG $0xc9bc0f48 // bsfq %rcx, %rcx WORD $0xf983; BYTE $0x10 // cmpl $16, %ecx - LONG $0x0014840f; WORD $0x0000 // je LBB27_11, $20(%rip) + LONG $0x0014840f; WORD $0x0000 // je LBB22_9, $20(%rip) LONG $0xffffffbb; BYTE $0xff // movl $-1, %ebx WORD $0xe3d3 // shll %cl, %ebx WORD $0xd3f7 // notl %ebx WORD $0xda21 // andl %ebx, %edx WORD $0x2141; BYTE $0xdf // andl %ebx, %r15d - WORD $0x2144; BYTE $0xdb // andl %r11d, %ebx - WORD $0x8941; BYTE $0xdb // movl %ebx, %r11d + WORD $0x2144; BYTE $0xf3 // andl %r14d, %ebx + WORD $0x8941; BYTE $0xde // movl %ebx, %r14d -LBB27_11: +LBB22_9: WORD $0x5a8d; BYTE $0xff // leal $-1(%rdx), %ebx WORD $0xd321 // andl %edx, %ebx - LONG $0x020d850f; WORD $0x0000 // jne LBB27_12, $525(%rip) + LONG $0x0202850f; WORD $0x0000 // jne LBB22_50, $514(%rip) LONG $0xff5f8d41 // leal $-1(%r15), %ebx WORD $0x2144; BYTE $0xfb // andl %r15d, %ebx - LONG $0x0200850f; WORD $0x0000 // jne LBB27_12, $512(%rip) - LONG $0xff5b8d41 // leal $-1(%r11), %ebx - WORD $0x2144; BYTE $0xdb // andl %r11d, %ebx - LONG $0x01f3850f; WORD $0x0000 // jne LBB27_12, $499(%rip) + LONG $0x01f5850f; WORD $0x0000 // jne LBB22_50, $501(%rip) + LONG $0xff5e8d41 // leal $-1(%r14), %ebx + WORD $0x2144; BYTE $0xf3 // andl %r14d, %ebx + LONG $0x01e8850f; WORD $0x0000 // jne LBB22_50, $488(%rip) WORD $0xd285 // testl %edx, %edx - LONG $0x0013840f; WORD $0x0000 // je LBB27_19, $19(%rip) + LONG $0x0019840f; WORD $0x0000 // je LBB22_15, $25(%rip) + WORD $0x894c; BYTE $0xd3 // movq %r10, %rbx + WORD $0x2948; BYTE $0xfb // subq %rdi, %rbx WORD $0xbc0f; BYTE $0xd2 // bsfl %edx, %edx + WORD $0x0148; BYTE $0xda // addq %rbx, %rdx LONG $0xfff88349 // cmpq $-1, %r8 - LONG $0x01f4850f; WORD $0x0000 // jne LBB27_56, $500(%rip) - WORD $0x0148; BYTE $0xc2 // addq %rax, %rdx + LONG $0x01d3850f; WORD $0x0000 // jne LBB22_51, $467(%rip) WORD $0x8949; BYTE $0xd0 // movq %rdx, %r8 -LBB27_19: +LBB22_15: WORD $0x8545; BYTE $0xff // testl %r15d, %r15d - LONG $0x0014840f; WORD $0x0000 // je LBB27_22, $20(%rip) + LONG $0x001a840f; WORD $0x0000 // je LBB22_18, $26(%rip) + WORD $0x894c; BYTE $0xd3 // movq %r10, %rbx + WORD $0x2948; BYTE $0xfb // subq %rdi, %rbx LONG $0xd7bc0f41 // bsfl %r15d, %edx + WORD $0x0148; BYTE $0xda // addq %rbx, %rdx + LONG $0xfff88348 // cmpq $-1, %rax + LONG $0x01b0850f; WORD $0x0000 // jne LBB22_51, $432(%rip) + WORD $0x8948; BYTE $0xd0 // movq %rdx, %rax + +LBB22_18: + WORD $0x8545; BYTE $0xf6 // testl %r14d, %r14d + LONG $0x001a840f; WORD $0x0000 // je LBB22_21, $26(%rip) + WORD $0x894c; BYTE $0xd3 // movq %r10, %rbx + WORD $0x2948; BYTE $0xfb // subq %rdi, %rbx + LONG $0xd6bc0f41 // bsfl %r14d, %edx + WORD $0x0148; BYTE $0xda // addq %rbx, %rdx LONG $0xfff98349 // cmpq $-1, %r9 - LONG $0x01d7850f; WORD $0x0000 // jne LBB27_56, $471(%rip) - WORD $0x0148; BYTE $0xc2 // addq %rax, %rdx + LONG $0x018d850f; WORD $0x0000 // jne LBB22_51, $397(%rip) WORD $0x8949; BYTE $0xd1 // movq %rdx, %r9 -LBB27_22: - WORD $0x8545; BYTE $0xdb // testl %r11d, %r11d - LONG $0x0014840f; WORD $0x0000 // je LBB27_25, $20(%rip) - LONG $0xd3bc0f41 // bsfl %r11d, %edx - LONG $0xfffa8349 // cmpq $-1, %r10 - LONG $0x01ba850f; WORD $0x0000 // jne LBB27_56, $442(%rip) - WORD $0x0148; BYTE $0xc2 // addq %rax, %rdx - WORD $0x8949; BYTE $0xd2 // movq %rdx, %r10 - -LBB27_25: +LBB22_21: WORD $0xf983; BYTE $0x10 // cmpl $16, %ecx - LONG $0x00c0850f; WORD $0x0000 // jne LBB27_57, $192(%rip) - LONG $0xf0c68349 // addq $-16, %r14 - LONG $0x10c08348 // addq $16, %rax - LONG $0x0ffe8349 // cmpq $15, %r14 - LONG $0xfeeb870f; WORD $0xffff // ja LBB27_9, $-277(%rip) - LONG $0x070c8d48 // leaq (%rdi,%rax), %rcx - WORD $0x8949; BYTE $0xcb // movq %rcx, %r11 - WORD $0x3948; BYTE $0xf0 // cmpq %rsi, %rax - LONG $0x00a7840f; WORD $0x0000 // je LBB27_41, $167(%rip) - -LBB27_28: - LONG $0x311c8d4e // leaq (%rcx,%r14), %r11 - WORD $0x8948; BYTE $0xce // movq %rcx, %rsi - WORD $0x2948; BYTE $0xfe // subq %rdi, %rsi - WORD $0xc031 // xorl %eax, %eax - LONG $0xa43d8d4c; WORD $0x0001; BYTE $0x00 // leaq $420(%rip), %r15 /* LJTI27_0(%rip) */ - LONG $0x00002fe9; BYTE $0x00 // jmp LBB27_29, $47(%rip) - -LBB27_31: - WORD $0xfa83; BYTE $0x65 // cmpl $101, %edx - LONG $0x009b850f; WORD $0x0000 // jne LBB27_40, $155(%rip) - -LBB27_32: - LONG $0xfff98349 // cmpq $-1, %r9 - LONG $0x0150850f; WORD $0x0000 // jne LBB27_58, $336(%rip) - LONG $0x060c8d4c // leaq (%rsi,%rax), %r9 - QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90 + LONG $0x00bf850f; WORD $0x0000 // jne LBB22_35, $191(%rip) + LONG $0x10c28349 // addq $16, %r10 + LONG $0xf0c68348 // addq $-16, %rsi + LONG $0x0ffe8348 // cmpq $15, %rsi + LONG $0xfed7870f; WORD $0xffff // ja LBB22_7, $-297(%rip) + WORD $0x8548; BYTE $0xf6 // testq %rsi, %rsi + LONG $0x00a7840f; WORD $0x0000 // je LBB22_36, $167(%rip) -LBB27_39: - WORD $0xff48; BYTE $0xc0 // incq %rax - WORD $0x3949; BYTE $0xc6 // cmpq %rax, %r14 - LONG $0x0060840f; WORD $0x0000 // je LBB27_41, $96(%rip) +LBB22_24: + LONG $0x321c8d4d // leaq (%r10,%rsi), %r11 + LONG $0xa71d8d48; WORD $0x0001; BYTE $0x00 // leaq $423(%rip), %rbx /* LJTI22_0(%rip) */ + LONG $0x00001ae9; BYTE $0x00 // jmp LBB22_26, $26(%rip) + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 -LBB27_29: - LONG $0x0114be0f // movsbl (%rcx,%rax), %edx - WORD $0x5a8d; BYTE $0xd0 // leal $-48(%rdx), %ebx - WORD $0xfb83; BYTE $0x0a // cmpl $10, %ebx - LONG $0xffe4820f; WORD $0xffff // jb LBB27_39, $-28(%rip) - WORD $0x5a8d; BYTE $0xd5 // leal $-43(%rdx), %ebx - WORD $0xfb83; BYTE $0x1a // cmpl $26, %ebx - LONG $0xffb5870f; WORD $0xffff // ja LBB27_31, $-75(%rip) - LONG $0x9f146349 // movslq (%r15,%rbx,4), %rdx - WORD $0x014c; BYTE $0xfa // addq %r15, %rdx +LBB22_25: + WORD $0x8949; BYTE $0xca // movq %rcx, %r10 + WORD $0xff48; BYTE $0xce // decq %rsi + LONG $0x0149840f; WORD $0x0000 // je LBB22_54, $329(%rip) + +LBB22_26: + LONG $0x12be0f41 // movsbl (%r10), %edx + WORD $0xc283; BYTE $0xd5 // addl $-43, %edx + WORD $0xfa83; BYTE $0x3a // cmpl $58, %edx + LONG $0x006d870f; WORD $0x0000 // ja LBB22_36, $109(%rip) + LONG $0x014a8d49 // leaq $1(%r10), %rcx + LONG $0x93146348 // movslq (%rbx,%rdx,4), %rdx + WORD $0x0148; BYTE $0xda // addq %rbx, %rdx JMP DX -LBB27_37: - LONG $0xfffa8349 // cmpq $-1, %r10 - LONG $0x0105850f; WORD $0x0000 // jne LBB27_58, $261(%rip) - LONG $0x06148d4c // leaq (%rsi,%rax), %r10 - LONG $0xffffbce9; BYTE $0xff // jmp LBB27_39, $-68(%rip) +LBB22_28: + WORD $0x8948; BYTE $0xca // movq %rcx, %rdx + WORD $0x2948; BYTE $0xfa // subq %rdi, %rdx + LONG $0xfff98349 // cmpq $-1, %r9 + LONG $0x0134850f; WORD $0x0000 // jne LBB22_58, $308(%rip) + WORD $0xff48; BYTE $0xca // decq %rdx + WORD $0x8949; BYTE $0xd1 // movq %rdx, %r9 + LONG $0xffffbce9; BYTE $0xff // jmp LBB22_25, $-68(%rip) -LBB27_35: +LBB22_30: + WORD $0x8948; BYTE $0xca // movq %rcx, %rdx + WORD $0x2948; BYTE $0xfa // subq %rdi, %rdx + LONG $0xfff88348 // cmpq $-1, %rax + LONG $0x0119850f; WORD $0x0000 // jne LBB22_58, $281(%rip) + WORD $0xff48; BYTE $0xca // decq %rdx + WORD $0x8948; BYTE $0xd0 // movq %rdx, %rax + LONG $0xffffa1e9; BYTE $0xff // jmp LBB22_25, $-95(%rip) + +LBB22_32: + WORD $0x8948; BYTE $0xca // movq %rcx, %rdx + WORD $0x2948; BYTE $0xfa // subq %rdi, %rdx LONG $0xfff88349 // cmpq $-1, %r8 - LONG $0x00f2850f; WORD $0x0000 // jne LBB27_58, $242(%rip) - LONG $0x06048d4c // leaq (%rsi,%rax), %r8 - LONG $0xffffa9e9; BYTE $0xff // jmp LBB27_39, $-87(%rip) + LONG $0x00fe850f; WORD $0x0000 // jne LBB22_58, $254(%rip) + WORD $0xff48; BYTE $0xca // decq %rdx + WORD $0x8949; BYTE $0xd0 // movq %rdx, %r8 + LONG $0xffff86e9; BYTE $0xff // jmp LBB22_25, $-122(%rip) -LBB27_1: +LBB22_34: LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax - LONG $0x00008fe9; BYTE $0x00 // jmp LBB27_55, $143(%rip) - -LBB27_57: - WORD $0x8941; BYTE $0xcb // movl %ecx, %r11d - WORD $0x0149; BYTE $0xfb // addq %rdi, %r11 - WORD $0x0149; BYTE $0xc3 // addq %rax, %r11 + LONG $0x0000c8e9; BYTE $0x00 // jmp LBB22_53, $200(%rip) -LBB27_41: - LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax - WORD $0x854d; BYTE $0xc0 // testq %r8, %r8 - LONG $0x001b850f; WORD $0x0000 // jne LBB27_42, $27(%rip) - LONG $0x000071e9; BYTE $0x00 // jmp LBB27_55, $113(%rip) +LBB22_35: + WORD $0x0149; BYTE $0xca // addq %rcx, %r10 -LBB27_40: - WORD $0x0148; BYTE $0xc1 // addq %rax, %rcx - WORD $0x8949; BYTE $0xcb // movq %rcx, %r11 - LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax - WORD $0x854d; BYTE $0xc0 // testq %r8, %r8 - LONG $0x005b840f; WORD $0x0000 // je LBB27_55, $91(%rip) +LBB22_36: + LONG $0xffc2c748; WORD $0xffff; BYTE $0xff // movq $-1, %rdx + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0x00b2840f; WORD $0x0000 // je LBB22_52, $178(%rip) -LBB27_42: - WORD $0x854d; BYTE $0xd2 // testq %r10, %r10 - LONG $0x0052840f; WORD $0x0000 // je LBB27_55, $82(%rip) +LBB22_37: + WORD $0x854d; BYTE $0xc9 // testq %r9, %r9 + LONG $0x00a9840f; WORD $0x0000 // je LBB22_52, $169(%rip) + WORD $0x854d; BYTE $0xc0 // testq %r8, %r8 + LONG $0x00a0840f; WORD $0x0000 // je LBB22_52, $160(%rip) + WORD $0x2949; BYTE $0xfa // subq %rdi, %r10 + LONG $0xff4a8d49 // leaq $-1(%r10), %rcx + WORD $0x3948; BYTE $0xc8 // cmpq %rcx, %rax + LONG $0x0036840f; WORD $0x0000 // je LBB22_45, $54(%rip) + WORD $0x3949; BYTE $0xc8 // cmpq %rcx, %r8 + LONG $0x002d840f; WORD $0x0000 // je LBB22_45, $45(%rip) + WORD $0x3949; BYTE $0xc9 // cmpq %rcx, %r9 + LONG $0x0024840f; WORD $0x0000 // je LBB22_45, $36(%rip) WORD $0x854d; BYTE $0xc9 // testq %r9, %r9 - LONG $0x0049840f; WORD $0x0000 // je LBB27_55, $73(%rip) - WORD $0x2949; BYTE $0xfb // subq %rdi, %r11 - LONG $0xff438d49 // leaq $-1(%r11), %rax + LONG $0x00298e0f; WORD $0x0000 // jle LBB22_46, $41(%rip) + LONG $0xff498d49 // leaq $-1(%r9), %rcx + WORD $0x3948; BYTE $0xc8 // cmpq %rcx, %rax + LONG $0x001c840f; WORD $0x0000 // je LBB22_46, $28(%rip) + WORD $0xf749; BYTE $0xd1 // notq %r9 + WORD $0x894c; BYTE $0xca // movq %r9, %rdx + WORD $0x894c; BYTE $0xc8 // movq %r9, %rax + LONG $0x00005de9; BYTE $0x00 // jmp LBB22_53, $93(%rip) + +LBB22_45: + WORD $0xf749; BYTE $0xda // negq %r10 + WORD $0x894c; BYTE $0xd2 // movq %r10, %rdx + WORD $0x894c; BYTE $0xd0 // movq %r10, %rax + LONG $0x00004fe9; BYTE $0x00 // jmp LBB22_53, $79(%rip) + +LBB22_46: + WORD $0x894c; BYTE $0xc1 // movq %r8, %rcx + WORD $0x0948; BYTE $0xc1 // orq %rax, %rcx WORD $0x3949; BYTE $0xc0 // cmpq %rax, %r8 - LONG $0x0033840f; WORD $0x0000 // je LBB27_47, $51(%rip) - WORD $0x3949; BYTE $0xc2 // cmpq %rax, %r10 - LONG $0x002a840f; WORD $0x0000 // je LBB27_47, $42(%rip) - WORD $0x3949; BYTE $0xc1 // cmpq %rax, %r9 - LONG $0x0021840f; WORD $0x0000 // je LBB27_47, $33(%rip) - WORD $0x854d; BYTE $0xd2 // testq %r10, %r10 - LONG $0x00258e0f; WORD $0x0000 // jle LBB27_51, $37(%rip) - LONG $0xff428d49 // leaq $-1(%r10), %rax - WORD $0x3949; BYTE $0xc1 // cmpq %rax, %r9 - LONG $0x0018840f; WORD $0x0000 // je LBB27_51, $24(%rip) - WORD $0xf749; BYTE $0xd2 // notq %r10 - WORD $0x894c; BYTE $0xd0 // movq %r10, %rax - LONG $0x000006e9; BYTE $0x00 // jmp LBB27_55, $6(%rip) + LONG $0x00178c0f; WORD $0x0000 // jl LBB22_49, $23(%rip) + WORD $0x8548; BYTE $0xc9 // testq %rcx, %rcx + LONG $0x000e880f; WORD $0x0000 // js LBB22_49, $14(%rip) + WORD $0xf749; BYTE $0xd0 // notq %r8 + WORD $0x894c; BYTE $0xc2 // movq %r8, %rdx + WORD $0x894c; BYTE $0xc0 // movq %r8, %rax + LONG $0x000029e9; BYTE $0x00 // jmp LBB22_53, $41(%rip) -LBB27_47: - WORD $0xf749; BYTE $0xdb // negq %r11 - WORD $0x894c; BYTE $0xd8 // movq %r11, %rax +LBB22_49: + LONG $0xff508d48 // leaq $-1(%rax), %rdx + WORD $0x8548; BYTE $0xc9 // testq %rcx, %rcx + WORD $0xf748; BYTE $0xd0 // notq %rax + LONG $0xc2480f49 // cmovsq %r10, %rax + WORD $0x3949; BYTE $0xd0 // cmpq %rdx, %r8 + LONG $0xc2450f49 // cmovneq %r10, %rax + LONG $0x00000fe9; BYTE $0x00 // jmp LBB22_53, $15(%rip) -LBB27_55: +LBB22_50: + WORD $0x2949; BYTE $0xfa // subq %rdi, %r10 + WORD $0xbc0f; BYTE $0xd3 // bsfl %ebx, %edx + WORD $0x014c; BYTE $0xd2 // addq %r10, %rdx + +LBB22_51: + WORD $0xf748; BYTE $0xd2 // notq %rdx + +LBB22_52: + WORD $0x8948; BYTE $0xd0 // movq %rdx, %rax + +LBB22_53: BYTE $0x5b // popq %rbx WORD $0x5e41 // popq %r14 WORD $0x5f41 // popq %r15 BYTE $0x5d // popq %rbp BYTE $0xc3 // retq -LBB27_51: - WORD $0x894c; BYTE $0xc0 // movq %r8, %rax - WORD $0x094c; BYTE $0xc8 // orq %r9, %rax - WORD $0x990f; BYTE $0xc0 // setns %al - LONG $0x0014880f; WORD $0x0000 // js LBB27_54, $20(%rip) - WORD $0x394d; BYTE $0xc8 // cmpq %r9, %r8 - LONG $0x000b8c0f; WORD $0x0000 // jl LBB27_54, $11(%rip) - WORD $0xf749; BYTE $0xd0 // notq %r8 - WORD $0x894c; BYTE $0xc0 // movq %r8, %rax - LONG $0xffffd6e9; BYTE $0xff // jmp LBB27_55, $-42(%rip) - -LBB27_54: - LONG $0xff498d49 // leaq $-1(%r9), %rcx - WORD $0x3949; BYTE $0xc8 // cmpq %rcx, %r8 - WORD $0xf749; BYTE $0xd1 // notq %r9 - LONG $0xcb450f4d // cmovneq %r11, %r9 - WORD $0xc084 // testb %al, %al - LONG $0xcb440f4d // cmoveq %r11, %r9 - WORD $0x894c; BYTE $0xc8 // movq %r9, %rax - LONG $0xffffbae9; BYTE $0xff // jmp LBB27_55, $-70(%rip) - -LBB27_12: - WORD $0xbc0f; BYTE $0xcb // bsfl %ebx, %ecx - LONG $0x000010e9; BYTE $0x00 // jmp LBB27_13, $16(%rip) - -LBB27_58: - WORD $0x2948; BYTE $0xcf // subq %rcx, %rdi - WORD $0xf748; BYTE $0xd0 // notq %rax - WORD $0x0148; BYTE $0xf8 // addq %rdi, %rax - LONG $0xffffa4e9; BYTE $0xff // jmp LBB27_55, $-92(%rip) - -LBB27_56: - WORD $0xd189 // movl %edx, %ecx +LBB22_54: + WORD $0x894d; BYTE $0xda // movq %r11, %r10 + LONG $0xffc2c748; WORD $0xffff; BYTE $0xff // movq $-1, %rdx + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0xff31850f; WORD $0xffff // jne LBB22_37, $-207(%rip) + LONG $0xffffdee9; BYTE $0xff // jmp LBB22_52, $-34(%rip) -LBB27_13: - WORD $0xf748; BYTE $0xd0 // notq %rax - WORD $0x2948; BYTE $0xc8 // subq %rcx, %rax - LONG $0xffff97e9; BYTE $0xff // jmp LBB27_55, $-105(%rip) +LBB22_58: + WORD $0xf748; BYTE $0xda // negq %rdx + LONG $0xffffd6e9; BYTE $0xff // jmp LBB22_52, $-42(%rip) -LBB27_7: +LBB22_57: LONG $0xffc0c749; WORD $0xffff; BYTE $0xff // movq $-1, %r8 - WORD $0x8948; BYTE $0xf9 // movq %rdi, %rcx - WORD $0x8949; BYTE $0xf6 // movq %rsi, %r14 + WORD $0x8949; BYTE $0xfa // movq %rdi, %r10 + LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax LONG $0xffc1c749; WORD $0xffff; BYTE $0xff // movq $-1, %r9 - LONG $0xffc2c749; WORD $0xffff; BYTE $0xff // movq $-1, %r10 - LONG $0xfffe4ae9; BYTE $0xff // jmp LBB27_28, $-438(%rip) - BYTE $0x90 // .p2align 2, 0x90 - - // .set L27_0_set_37, LBB27_37-LJTI27_0 - // .set L27_0_set_40, LBB27_40-LJTI27_0 - // .set L27_0_set_35, LBB27_35-LJTI27_0 - // .set L27_0_set_32, LBB27_32-LJTI27_0 -LJTI27_0: - LONG $0xfffffeb5 // .long L27_0_set_37 - LONG $0xffffff05 // .long L27_0_set_40 - LONG $0xfffffeb5 // .long L27_0_set_37 - LONG $0xfffffec8 // .long L27_0_set_35 - LONG $0xffffff05 // .long L27_0_set_40 - LONG $0xffffff05 // .long L27_0_set_40 - LONG $0xffffff05 // .long L27_0_set_40 - LONG $0xffffff05 // .long L27_0_set_40 - LONG $0xffffff05 // .long L27_0_set_40 - LONG $0xffffff05 // .long L27_0_set_40 - LONG $0xffffff05 // .long L27_0_set_40 - LONG $0xffffff05 // .long L27_0_set_40 - LONG $0xffffff05 // .long L27_0_set_40 - LONG $0xffffff05 // .long L27_0_set_40 - LONG $0xffffff05 // .long L27_0_set_40 - LONG $0xffffff05 // .long L27_0_set_40 - LONG $0xffffff05 // .long L27_0_set_40 - LONG $0xffffff05 // .long L27_0_set_40 - LONG $0xffffff05 // .long L27_0_set_40 - LONG $0xffffff05 // .long L27_0_set_40 - LONG $0xffffff05 // .long L27_0_set_40 - LONG $0xffffff05 // .long L27_0_set_40 - LONG $0xffffff05 // .long L27_0_set_40 - LONG $0xffffff05 // .long L27_0_set_40 - LONG $0xffffff05 // .long L27_0_set_40 - LONG $0xffffff05 // .long L27_0_set_40 - LONG $0xfffffe6a // .long L27_0_set_32 - QUAD $0x9090909090909090 // .p2align 4, 0x90 + LONG $0xfffe50e9; BYTE $0xff // jmp LBB22_24, $-432(%rip) + WORD $0x9090 // .p2align 2, 0x90 + + // .set L22_0_set_28, LBB22_28-LJTI22_0 + // .set L22_0_set_36, LBB22_36-LJTI22_0 + // .set L22_0_set_32, LBB22_32-LJTI22_0 + // .set L22_0_set_25, LBB22_25-LJTI22_0 + // .set L22_0_set_30, LBB22_30-LJTI22_0 +LJTI22_0: + LONG $0xfffffe95 // .long L22_0_set_28 + LONG $0xfffffef5 // .long L22_0_set_36 + LONG $0xfffffe95 // .long L22_0_set_28 + LONG $0xfffffecb // .long L22_0_set_32 + LONG $0xfffffef5 // .long L22_0_set_36 + LONG $0xfffffe6c // .long L22_0_set_25 + LONG $0xfffffe6c // .long L22_0_set_25 + LONG $0xfffffe6c // .long L22_0_set_25 + LONG $0xfffffe6c // .long L22_0_set_25 + LONG $0xfffffe6c // .long L22_0_set_25 + LONG $0xfffffe6c // .long L22_0_set_25 + LONG $0xfffffe6c // .long L22_0_set_25 + LONG $0xfffffe6c // .long L22_0_set_25 + LONG $0xfffffe6c // .long L22_0_set_25 + LONG $0xfffffe6c // .long L22_0_set_25 + LONG $0xfffffef5 // .long L22_0_set_36 + LONG $0xfffffef5 // .long L22_0_set_36 + LONG $0xfffffef5 // .long L22_0_set_36 + LONG $0xfffffef5 // .long L22_0_set_36 + LONG $0xfffffef5 // .long L22_0_set_36 + LONG $0xfffffef5 // .long L22_0_set_36 + LONG $0xfffffef5 // .long L22_0_set_36 + LONG $0xfffffef5 // .long L22_0_set_36 + LONG $0xfffffef5 // .long L22_0_set_36 + LONG $0xfffffef5 // .long L22_0_set_36 + LONG $0xfffffef5 // .long L22_0_set_36 + LONG $0xfffffeb0 // .long L22_0_set_30 + LONG $0xfffffef5 // .long L22_0_set_36 + LONG $0xfffffef5 // .long L22_0_set_36 + LONG $0xfffffef5 // .long L22_0_set_36 + LONG $0xfffffef5 // .long L22_0_set_36 + LONG $0xfffffef5 // .long L22_0_set_36 + LONG $0xfffffef5 // .long L22_0_set_36 + LONG $0xfffffef5 // .long L22_0_set_36 + LONG $0xfffffef5 // .long L22_0_set_36 + LONG $0xfffffef5 // .long L22_0_set_36 + LONG $0xfffffef5 // .long L22_0_set_36 + LONG $0xfffffef5 // .long L22_0_set_36 + LONG $0xfffffef5 // .long L22_0_set_36 + LONG $0xfffffef5 // .long L22_0_set_36 + LONG $0xfffffef5 // .long L22_0_set_36 + LONG $0xfffffef5 // .long L22_0_set_36 + LONG $0xfffffef5 // .long L22_0_set_36 + LONG $0xfffffef5 // .long L22_0_set_36 + LONG $0xfffffef5 // .long L22_0_set_36 + LONG $0xfffffef5 // .long L22_0_set_36 + LONG $0xfffffef5 // .long L22_0_set_36 + LONG $0xfffffef5 // .long L22_0_set_36 + LONG $0xfffffef5 // .long L22_0_set_36 + LONG $0xfffffef5 // .long L22_0_set_36 + LONG $0xfffffef5 // .long L22_0_set_36 + LONG $0xfffffef5 // .long L22_0_set_36 + LONG $0xfffffef5 // .long L22_0_set_36 + LONG $0xfffffef5 // .long L22_0_set_36 + LONG $0xfffffef5 // .long L22_0_set_36 + LONG $0xfffffef5 // .long L22_0_set_36 + LONG $0xfffffef5 // .long L22_0_set_36 + LONG $0xfffffef5 // .long L22_0_set_36 + LONG $0xfffffeb0 // .long L22_0_set_30 + // .p2align 4, 0x90 _skip_positive: BYTE $0x55 // pushq %rbp WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp @@ -6708,7 +6422,7 @@ _skip_positive: LONG $0x08778b48 // movq $8(%rdi), %rsi WORD $0x2948; BYTE $0xde // subq %rbx, %rsi WORD $0x8948; BYTE $0xc7 // movq %rax, %rdi - LONG $0xfffbd7e8; BYTE $0xff // callq _do_skip_number, $-1065(%rip) + LONG $0xfffb47e8; BYTE $0xff // callq _do_skip_number, $-1209(%rip) LONG $0xff508d48 // leaq $-1(%rax), %rdx LONG $0xfec1c748; WORD $0xffff; BYTE $0xff // movq $-2, %rcx LONG $0xfec6c748; WORD $0xffff; BYTE $0xff // movq $-2, %rsi @@ -6744,22 +6458,22 @@ _skip_number: WORD $0x940f; BYTE $0xc0 // sete %al WORD $0x0148; BYTE $0xc3 // addq %rax, %rbx WORD $0x2948; BYTE $0xc6 // subq %rax, %rsi - LONG $0x003c840f; WORD $0x0000 // je LBB29_6, $60(%rip) + LONG $0x003b840f; WORD $0x0000 // je LBB24_6, $59(%rip) WORD $0x3949; BYTE $0xf7 // cmpq %rsi, %r15 - LONG $0x000d830f; WORD $0x0000 // jae LBB29_3, $13(%rip) - WORD $0xb60f; BYTE $0x03 // movzbl (%rbx), %eax - WORD $0xc604 // addb $-58, %al - WORD $0xf63c // cmpb $-10, %al - LONG $0x0038820f; WORD $0x0000 // jb LBB29_8, $56(%rip) + LONG $0x000c830f; WORD $0x0000 // jae LBB24_3, $12(%rip) + WORD $0x038a // movb (%rbx), %al + WORD $0xd004 // addb $-48, %al + WORD $0x093c // cmpb $9, %al + LONG $0x0038870f; WORD $0x0000 // ja LBB24_8, $56(%rip) -LBB29_3: +LBB24_3: WORD $0x8948; BYTE $0xdf // movq %rbx, %rdi - LONG $0xfffb50e8; BYTE $0xff // callq _do_skip_number, $-1200(%rip) + LONG $0xfffac1e8; BYTE $0xff // callq _do_skip_number, $-1343(%rip) WORD $0x8548; BYTE $0xc0 // testq %rax, %rax - LONG $0x0021880f; WORD $0x0000 // js LBB29_7, $33(%rip) + LONG $0x0021880f; WORD $0x0000 // js LBB24_7, $33(%rip) WORD $0x0148; BYTE $0xc3 // addq %rax, %rbx -LBB29_5: +LBB24_5: WORD $0x294c; BYTE $0xe3 // subq %r12, %rbx WORD $0x8949; BYTE $0x1e // movq %rbx, (%r14) WORD $0x894c; BYTE $0xf8 // movq %r15, %rax @@ -6770,20 +6484,20 @@ LBB29_5: BYTE $0x5d // popq %rbp BYTE $0xc3 // retq -LBB29_6: +LBB24_6: LONG $0xffc7c749; WORD $0xffff; BYTE $0xff // movq $-1, %r15 - LONG $0xffffe2e9; BYTE $0xff // jmp LBB29_5, $-30(%rip) + LONG $0xffffe2e9; BYTE $0xff // jmp LBB24_5, $-30(%rip) -LBB29_7: +LBB24_7: WORD $0xf748; BYTE $0xd0 // notq %rax WORD $0x0148; BYTE $0xc3 // addq %rax, %rbx -LBB29_8: +LBB24_8: LONG $0xfec7c749; WORD $0xffff; BYTE $0xff // movq $-2, %r15 - LONG $0xffffd0e9; BYTE $0xff // jmp LBB29_5, $-48(%rip) - LONG $0x00000000 // .p2align 4, 0x00 + LONG $0xffffd0e9; BYTE $0xff // jmp LBB24_5, $-48(%rip) + LONG $0x00000000; BYTE $0x00 // .p2align 4, 0x00 -LCPI30_0: +LCPI25_0: LONG $0x00000001 // .long 1 LONG $0x00000000 // .long 0 LONG $0x00000000 // .long 0 @@ -6796,14 +6510,14 @@ _skip_one: WORD $0x8948; BYTE $0xd0 // movq %rdx, %rax WORD $0x8948; BYTE $0xf2 // movq %rsi, %rdx WORD $0x8948; BYTE $0xfe // movq %rdi, %rsi - LONG $0xdc05280f; WORD $0xffff; BYTE $0xff // movaps $-36(%rip), %xmm0 /* LCPI30_0(%rip) */ + LONG $0xdc05280f; WORD $0xffff; BYTE $0xff // movaps $-36(%rip), %xmm0 /* LCPI25_0(%rip) */ WORD $0x110f; BYTE $0x00 // movups %xmm0, (%rax) WORD $0x8948; BYTE $0xc7 // movq %rax, %rdi BYTE $0x5d // popq %rbp - LONG $0xfff250e9; BYTE $0xff // jmp _fsm_exec, $-3504(%rip) + LONG $0xffefb0e9; BYTE $0xff // jmp _fsm_exec, $-4176(%rip) // .p2align 4, 0x00 -LCPI31_0: +LCPI26_0: LONG $0x00000001 // .long 1 LONG $0x00000000 // .long 0 LONG $0x00000000 // .long 0 @@ -6816,136 +6530,225 @@ _validate_one: WORD $0x8948; BYTE $0xd0 // movq %rdx, %rax WORD $0x8948; BYTE $0xf2 // movq %rsi, %rdx WORD $0x8948; BYTE $0xfe // movq %rdi, %rsi - LONG $0xdc05280f; WORD $0xffff; BYTE $0xff // movaps $-36(%rip), %xmm0 /* LCPI31_0(%rip) */ + LONG $0xdc05280f; WORD $0xffff; BYTE $0xff // movaps $-36(%rip), %xmm0 /* LCPI26_0(%rip) */ WORD $0x110f; BYTE $0x00 // movups %xmm0, (%rax) LONG $0x000020b9; BYTE $0x00 // movl $32, %ecx WORD $0x8948; BYTE $0xc7 // movq %rax, %rdi BYTE $0x5d // popq %rbp - LONG $0xfff21be9; BYTE $0xff // jmp _fsm_exec, $-3557(%rip) + LONG $0xffef7be9; BYTE $0xff // jmp _fsm_exec, $-4229(%rip) QUAD $0x0000000000000000; WORD $0x0000; BYTE $0x00 // .p2align 4, 0x00 -LCPI32_0: +LCPI27_0: QUAD $0x2c2c2c2c2c2c2c2c; QUAD $0x2c2c2c2c2c2c2c2c // .space 16, ',,,,,,,,,,,,,,,,' -LCPI32_1: +LCPI27_1: QUAD $0xdfdfdfdfdfdfdfdf; QUAD $0xdfdfdfdfdfdfdfdf // .space 16, '\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf' -LCPI32_2: +LCPI27_2: QUAD $0x5d5d5d5d5d5d5d5d; QUAD $0x5d5d5d5d5d5d5d5d // .space 16, ']]]]]]]]]]]]]]]]' -LCPI32_3: +LCPI27_3: QUAD $0x2222222222222222; QUAD $0x2222222222222222 // .space 16, '""""""""""""""""' -LCPI32_4: +LCPI27_4: QUAD $0x5c5c5c5c5c5c5c5c; QUAD $0x5c5c5c5c5c5c5c5c // .space 16, '\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' -LCPI32_5: +LCPI27_5: QUAD $0x7b7b7b7b7b7b7b7b; QUAD $0x7b7b7b7b7b7b7b7b // .space 16, '{{{{{{{{{{{{{{{{' -LCPI32_6: +LCPI27_6: QUAD $0x7d7d7d7d7d7d7d7d; QUAD $0x7d7d7d7d7d7d7d7d // .space 16, '}}}}}}}}}}}}}}}}' -LCPI32_7: +LCPI27_7: QUAD $0x5b5b5b5b5b5b5b5b; QUAD $0x5b5b5b5b5b5b5b5b // .space 16, '[[[[[[[[[[[[[[[[' // .p2align 4, 0x90 _skip_one_fast: - BYTE $0x55 // pushq %rbp - WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp - WORD $0x5741 // pushq %r15 - WORD $0x5641 // pushq %r14 - WORD $0x5541 // pushq %r13 - WORD $0x5441 // pushq %r12 - BYTE $0x53 // pushq %rbx - LONG $0x68ec8348 // subq $104, %rsp - WORD $0x8949; BYTE $0xf5 // movq %rsi, %r13 - WORD $0x8949; BYTE $0xfe // movq %rdi, %r14 - WORD $0x8b48; BYTE $0x3f // movq (%rdi), %rdi - LONG $0x08768b49 // movq $8(%r14), %rsi - WORD $0x894c; BYTE $0xea // movq %r13, %rdx - LONG $0xffe01ae8; BYTE $0xff // callq _advance_ns, $-8166(%rip) - LONG $0x00558b49 // movq (%r13), %rdx - LONG $0xff428d4c // leaq $-1(%rdx), %r8 - WORD $0xbe0f; BYTE $0xc8 // movsbl %al, %ecx + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5741 // pushq %r15 + WORD $0x5641 // pushq %r14 + WORD $0x5541 // pushq %r13 + WORD $0x5441 // pushq %r12 + BYTE $0x53 // pushq %rbx + LONG $0x58ec8348 // subq $88, %rsp + WORD $0x8b4c; BYTE $0x07 // movq (%rdi), %r8 + LONG $0x084f8b4c // movq $8(%rdi), %r9 + WORD $0x8b48; BYTE $0x16 // movq (%rsi), %rdx + WORD $0x8948; BYTE $0xd0 // movq %rdx, %rax + WORD $0x294c; BYTE $0xc8 // subq %r9, %rax + LONG $0x002a830f; WORD $0x0000 // jae LBB27_5, $42(%rip) + LONG $0x100c8a41 // movb (%r8,%rdx), %cl + WORD $0xf980; BYTE $0x0d // cmpb $13, %cl + LONG $0x001d840f; WORD $0x0000 // je LBB27_5, $29(%rip) + WORD $0xf980; BYTE $0x20 // cmpb $32, %cl + LONG $0x0014840f; WORD $0x0000 // je LBB27_5, $20(%rip) + WORD $0xc180; BYTE $0xf7 // addb $-9, %cl + WORD $0xf980; BYTE $0x01 // cmpb $1, %cl + LONG $0x0008860f; WORD $0x0000 // jbe LBB27_5, $8(%rip) + WORD $0x8949; BYTE $0xd6 // movq %rdx, %r14 + LONG $0x00012ee9; BYTE $0x00 // jmp LBB27_27, $302(%rip) + +LBB27_5: + LONG $0x01728d4c // leaq $1(%rdx), %r14 + WORD $0x394d; BYTE $0xce // cmpq %r9, %r14 + LONG $0x0022830f; WORD $0x0000 // jae LBB27_9, $34(%rip) + LONG $0x300c8a43 // movb (%r8,%r14), %cl + WORD $0xf980; BYTE $0x0d // cmpb $13, %cl + LONG $0x0015840f; WORD $0x0000 // je LBB27_9, $21(%rip) + WORD $0xf980; BYTE $0x20 // cmpb $32, %cl + LONG $0x000c840f; WORD $0x0000 // je LBB27_9, $12(%rip) + WORD $0xc180; BYTE $0xf7 // addb $-9, %cl + WORD $0xf980; BYTE $0x01 // cmpb $1, %cl + LONG $0x00ff870f; WORD $0x0000 // ja LBB27_27, $255(%rip) + +LBB27_9: + LONG $0x02728d4c // leaq $2(%rdx), %r14 + WORD $0x394d; BYTE $0xce // cmpq %r9, %r14 + LONG $0x0022830f; WORD $0x0000 // jae LBB27_13, $34(%rip) + LONG $0x300c8a43 // movb (%r8,%r14), %cl + WORD $0xf980; BYTE $0x0d // cmpb $13, %cl + LONG $0x0015840f; WORD $0x0000 // je LBB27_13, $21(%rip) + WORD $0xf980; BYTE $0x20 // cmpb $32, %cl + LONG $0x000c840f; WORD $0x0000 // je LBB27_13, $12(%rip) + WORD $0xc180; BYTE $0xf7 // addb $-9, %cl + WORD $0xf980; BYTE $0x01 // cmpb $1, %cl + LONG $0x00d0870f; WORD $0x0000 // ja LBB27_27, $208(%rip) + +LBB27_13: + LONG $0x03728d4c // leaq $3(%rdx), %r14 + WORD $0x394d; BYTE $0xce // cmpq %r9, %r14 + LONG $0x0022830f; WORD $0x0000 // jae LBB27_17, $34(%rip) + LONG $0x300c8a43 // movb (%r8,%r14), %cl + WORD $0xf980; BYTE $0x0d // cmpb $13, %cl + LONG $0x0015840f; WORD $0x0000 // je LBB27_17, $21(%rip) + WORD $0xf980; BYTE $0x20 // cmpb $32, %cl + LONG $0x000c840f; WORD $0x0000 // je LBB27_17, $12(%rip) + WORD $0xc180; BYTE $0xf7 // addb $-9, %cl + WORD $0xf980; BYTE $0x01 // cmpb $1, %cl + LONG $0x00a1870f; WORD $0x0000 // ja LBB27_27, $161(%rip) + +LBB27_17: + LONG $0x044a8d48 // leaq $4(%rdx), %rcx + WORD $0x3949; BYTE $0xc9 // cmpq %rcx, %r9 + LONG $0x004e860f; WORD $0x0000 // jbe LBB27_23, $78(%rip) + WORD $0x3949; BYTE $0xc9 // cmpq %rcx, %r9 + LONG $0x0054840f; WORD $0x0000 // je LBB27_24, $84(%rip) + LONG $0x080c8d4b // leaq (%r8,%r9), %rcx + LONG $0x04c08348 // addq $4, %rax + LONG $0x02748d4e; BYTE $0x05 // leaq $5(%rdx,%r8), %r14 + QUAD $0x000100002600ba48; WORD $0x0000 // movabsq $4294977024, %rdx + LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB27_20: + LONG $0x5ebe0f41; BYTE $0xff // movsbl $-1(%r14), %ebx + WORD $0xfb83; BYTE $0x20 // cmpl $32, %ebx + LONG $0x0048870f; WORD $0x0000 // ja LBB27_26, $72(%rip) + LONG $0xdaa30f48 // btq %rbx, %rdx + LONG $0x003e830f; WORD $0x0000 // jae LBB27_26, $62(%rip) + WORD $0xff49; BYTE $0xc6 // incq %r14 + WORD $0xff48; BYTE $0xc0 // incq %rax + LONG $0xffdc850f; WORD $0xffff // jne LBB27_20, $-36(%rip) + LONG $0x000012e9; BYTE $0x00 // jmp LBB27_25, $18(%rip) + +LBB27_23: + WORD $0x8948; BYTE $0x0e // movq %rcx, (%rsi) + LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax + LONG $0x000124e9; BYTE $0x00 // jmp LBB27_44, $292(%rip) + +LBB27_24: + WORD $0x014c; BYTE $0xc1 // addq %r8, %rcx + +LBB27_25: + WORD $0x294c; BYTE $0xc1 // subq %r8, %rcx + WORD $0x8949; BYTE $0xce // movq %rcx, %r14 + LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax + WORD $0x394d; BYTE $0xce // cmpq %r9, %r14 + LONG $0x001e820f; WORD $0x0000 // jb LBB27_27, $30(%rip) + LONG $0x000106e9; BYTE $0x00 // jmp LBB27_44, $262(%rip) + +LBB27_26: + WORD $0x894c; BYTE $0xc0 // movq %r8, %rax + WORD $0xf748; BYTE $0xd0 // notq %rax + WORD $0x0149; BYTE $0xc6 // addq %rax, %r14 + LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax + WORD $0x394d; BYTE $0xce // cmpq %r9, %r14 + LONG $0x00ed830f; WORD $0x0000 // jae LBB27_44, $237(%rip) + +LBB27_27: + LONG $0x015e8d49 // leaq $1(%r14), %rbx + WORD $0x8948; BYTE $0x1e // movq %rbx, (%rsi) + LONG $0x0cbe0f43; BYTE $0x30 // movsbl (%r8,%r14), %ecx WORD $0xf983; BYTE $0x7b // cmpl $123, %ecx - LONG $0x0119870f; WORD $0x0000 // ja LBB32_19, $281(%rip) + LONG $0x00fa870f; WORD $0x0000 // ja LBB27_46, $250(%rip) LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax - LONG $0x80358d48; WORD $0x000b; BYTE $0x00 // leaq $2944(%rip), %rsi /* LJTI32_0(%rip) */ - LONG $0x8e0c6348 // movslq (%rsi,%rcx,4), %rcx - WORD $0x0148; BYTE $0xf1 // addq %rsi, %rcx + LONG $0x7a158d48; WORD $0x000b; BYTE $0x00 // leaq $2938(%rip), %rdx /* LJTI27_0(%rip) */ + LONG $0x8a0c6348 // movslq (%rdx,%rcx,4), %rcx + WORD $0x0148; BYTE $0xd1 // addq %rdx, %rcx JMP CX -LBB32_2: - WORD $0x8b49; BYTE $0x06 // movq (%r14), %rax - LONG $0x084e8b49 // movq $8(%r14), %rcx - WORD $0x8948; BYTE $0xce // movq %rcx, %rsi - WORD $0x2948; BYTE $0xd6 // subq %rdx, %rsi - LONG $0x10fe8348 // cmpq $16, %rsi - LONG $0x0ab0820f; WORD $0x0000 // jb LBB32_84, $2736(%rip) - WORD $0x8948; BYTE $0xd6 // movq %rdx, %rsi - WORD $0xf748; BYTE $0xde // negq %rsi - QUAD $0xffffff0a056f0f66 // movdqa $-246(%rip), %xmm0 /* LCPI32_0(%rip) */ - QUAD $0xffffff120d6f0f66 // movdqa $-238(%rip), %xmm1 /* LCPI32_1(%rip) */ - QUAD $0xffffff1a156f0f66 // movdqa $-230(%rip), %xmm2 /* LCPI32_2(%rip) */ - QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90 +LBB27_29: + LONG $0x08478b48 // movq $8(%rdi), %rax + WORD $0x2948; BYTE $0xd8 // subq %rbx, %rax + WORD $0x014c; BYTE $0xc3 // addq %r8, %rbx + LONG $0x10f88348 // cmpq $16, %rax + LONG $0x0058820f; WORD $0x0000 // jb LBB27_33, $88(%rip) + QUAD $0xfffffdb9056f0f66 // movdqa $-583(%rip), %xmm0 /* LCPI27_0(%rip) */ + QUAD $0xfffffdc10d6f0f66 // movdqa $-575(%rip), %xmm1 /* LCPI27_1(%rip) */ + QUAD $0xfffffdc9156f0f66 // movdqa $-567(%rip), %xmm2 /* LCPI27_2(%rip) */ + QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90 -LBB32_4: - LONG $0x1c6f0ff3; BYTE $0x10 // movdqu (%rax,%rdx), %xmm3 +LBB27_31: + LONG $0x1b6f0ff3 // movdqu (%rbx), %xmm3 LONG $0xe36f0f66 // movdqa %xmm3, %xmm4 LONG $0xe0740f66 // pcmpeqb %xmm0, %xmm4 LONG $0xd9db0f66 // pand %xmm1, %xmm3 LONG $0xda740f66 // pcmpeqb %xmm2, %xmm3 LONG $0xdceb0f66 // por %xmm4, %xmm3 - LONG $0xfbd70f66 // pmovmskb %xmm3, %edi - WORD $0xff85 // testl %edi, %edi - LONG $0x006b850f; WORD $0x0000 // jne LBB32_14, $107(%rip) - LONG $0x10c28348 // addq $16, %rdx - LONG $0x313c8d48 // leaq (%rcx,%rsi), %rdi - LONG $0xf0c78348 // addq $-16, %rdi - LONG $0xf0c68348 // addq $-16, %rsi - LONG $0x0fff8348 // cmpq $15, %rdi - LONG $0xffc1870f; WORD $0xffff // ja LBB32_4, $-63(%rip) - WORD $0x8948; BYTE $0xc2 // movq %rax, %rdx - WORD $0x2948; BYTE $0xf2 // subq %rsi, %rdx - WORD $0x0148; BYTE $0xf1 // addq %rsi, %rcx - WORD $0x8948; BYTE $0xce // movq %rcx, %rsi - WORD $0x8548; BYTE $0xf6 // testq %rsi, %rsi - LONG $0x0034840f; WORD $0x0000 // je LBB32_13, $52(%rip) - -LBB32_7: - LONG $0x323c8d48 // leaq (%rdx,%rsi), %rdi - WORD $0xc931 // xorl %ecx, %ecx + LONG $0xcbd70f66 // pmovmskb %xmm3, %ecx + WORD $0x8566; BYTE $0xc9 // testw %cx, %cx + LONG $0x0054850f; WORD $0x0000 // jne LBB27_41, $84(%rip) + LONG $0x10c38348 // addq $16, %rbx + LONG $0xf0c08348 // addq $-16, %rax + LONG $0x0ff88348 // cmpq $15, %rax + LONG $0xffc9870f; WORD $0xffff // ja LBB27_31, $-55(%rip) + +LBB27_33: + WORD $0x8548; BYTE $0xc0 // testq %rax, %rax + LONG $0x0031840f; WORD $0x0000 // je LBB27_40, $49(%rip) + LONG $0x030c8d48 // leaq (%rbx,%rax), %rcx -LBB32_8: - LONG $0x0a1cb60f // movzbl (%rdx,%rcx), %ebx - WORD $0xfb83; BYTE $0x2c // cmpl $44, %ebx - LONG $0x09f5840f; WORD $0x0000 // je LBB32_82, $2549(%rip) - WORD $0xfb83; BYTE $0x7d // cmpl $125, %ebx - LONG $0x09ec840f; WORD $0x0000 // je LBB32_82, $2540(%rip) - WORD $0xfb83; BYTE $0x5d // cmpl $93, %ebx - LONG $0x09e3840f; WORD $0x0000 // je LBB32_82, $2531(%rip) - WORD $0xff48; BYTE $0xc1 // incq %rcx - WORD $0x3948; BYTE $0xce // cmpq %rcx, %rsi - LONG $0xffd5850f; WORD $0xffff // jne LBB32_8, $-43(%rip) - WORD $0x8948; BYTE $0xfa // movq %rdi, %rdx +LBB27_35: + WORD $0xb60f; BYTE $0x13 // movzbl (%rbx), %edx + WORD $0xfa80; BYTE $0x2c // cmpb $44, %dl + LONG $0x0021840f; WORD $0x0000 // je LBB27_40, $33(%rip) + WORD $0xfa80; BYTE $0x7d // cmpb $125, %dl + LONG $0x0018840f; WORD $0x0000 // je LBB27_40, $24(%rip) + WORD $0xfa80; BYTE $0x5d // cmpb $93, %dl + LONG $0x000f840f; WORD $0x0000 // je LBB27_40, $15(%rip) + WORD $0xff48; BYTE $0xc3 // incq %rbx + WORD $0xff48; BYTE $0xc8 // decq %rax + LONG $0xffd6850f; WORD $0xffff // jne LBB27_35, $-42(%rip) + WORD $0x8948; BYTE $0xcb // movq %rcx, %rbx -LBB32_13: - WORD $0x2948; BYTE $0xc2 // subq %rax, %rdx - LONG $0x0009d2e9; BYTE $0x00 // jmp LBB32_83, $2514(%rip) +LBB27_40: + WORD $0x294c; BYTE $0xc3 // subq %r8, %rbx + LONG $0x00000de9; BYTE $0x00 // jmp LBB27_42, $13(%rip) -LBB32_14: - LONG $0xc7bc0f66 // bsfw %di, %ax - WORD $0xb70f; BYTE $0xc0 // movzwl %ax, %eax - WORD $0x2948; BYTE $0xf0 // subq %rsi, %rax +LBB27_41: + WORD $0xb70f; BYTE $0xc1 // movzwl %cx, %eax + LONG $0xc0bc0f48 // bsfq %rax, %rax + WORD $0x294c; BYTE $0xc3 // subq %r8, %rbx + WORD $0x0148; BYTE $0xc3 // addq %rax, %rbx -LBB32_15: - LONG $0x00458949 // movq %rax, (%r13) +LBB27_42: + WORD $0x8948; BYTE $0x1e // movq %rbx, (%rsi) -LBB32_16: - WORD $0x894c; BYTE $0xc0 // movq %r8, %rax +LBB27_43: + WORD $0x894c; BYTE $0xf0 // movq %r14, %rax -LBB32_17: - LONG $0x68c48348 // addq $104, %rsp +LBB27_44: + LONG $0x58c48348 // addq $88, %rsp BYTE $0x5b // popq %rbx WORD $0x5c41 // popq %r12 WORD $0x5d41 // popq %r13 @@ -6954,49 +6757,49 @@ LBB32_17: BYTE $0x5d // popq %rbp BYTE $0xc3 // retq -LBB32_18: - LONG $0x03c28348 // addq $3, %rdx - LONG $0x08563b49 // cmpq $8(%r14), %rdx - LONG $0xffe3830f; WORD $0xffff // jae LBB32_17, $-29(%rip) - LONG $0x00099fe9; BYTE $0x00 // jmp LBB32_83, $2463(%rip) +LBB27_45: + LONG $0x044e8d49 // leaq $4(%r14), %rcx + LONG $0x084f3b48 // cmpq $8(%rdi), %rcx + LONG $0xffe3870f; WORD $0xffff // ja LBB27_44, $-29(%rip) + LONG $0x000560e9; BYTE $0x00 // jmp LBB27_82, $1376(%rip) -LBB32_19: - LONG $0x0045894d // movq %r8, (%r13) +LBB27_46: + WORD $0x894c; BYTE $0x36 // movq %r14, (%rsi) LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq $-2, %rax - LONG $0xffffcee9; BYTE $0xff // jmp LBB32_17, $-50(%rip) + LONG $0xffffcfe9; BYTE $0xff // jmp LBB27_44, $-49(%rip) -LBB32_20: - WORD $0x8b49; BYTE $0x0e // movq (%r14), %rcx - LONG $0x084e8b4d // movq $8(%r14), %r9 - LONG $0xd04d8948 // movq %rcx, $-48(%rbp) - LONG $0x11148d4c // leaq (%rcx,%rdx), %r10 - WORD $0x2949; BYTE $0xd1 // subq %rdx, %r9 - LONG $0x20f98349 // cmpq $32, %r9 - LONG $0x098b820f; WORD $0x0000 // jb LBB32_28, $2443(%rip) - WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d - QUAD $0xfffffe26056f0f66 // movdqa $-474(%rip), %xmm0 /* LCPI32_3(%rip) */ - QUAD $0xfffffe2e0d6f0f66 // movdqa $-466(%rip), %xmm1 /* LCPI32_4(%rip) */ +LBB27_47: + LONG $0x084f8b4c // movq $8(%rdi), %r9 + WORD $0x894d; BYTE $0xcf // movq %r9, %r15 + WORD $0x2949; BYTE $0xdf // subq %rbx, %r15 + LONG $0x20ff8349 // cmpq $32, %r15 + LONG $0x0a348c0f; WORD $0x0000 // jl LBB27_116, $2612(%rip) + LONG $0xffffba41; WORD $0xffff // movl $4294967295, %r10d + LONG $0x301c8d4f // leaq (%r8,%r14), %r11 + WORD $0x294d; BYTE $0xf1 // subq %r14, %r9 + LONG $0x001fbd41; WORD $0x0000 // movl $31, %r13d + WORD $0x3145; BYTE $0xff // xorl %r15d, %r15d + QUAD $0xfffffce1056f0f66 // movdqa $-799(%rip), %xmm0 /* LCPI27_3(%rip) */ + QUAD $0xfffffce90d6f0f66 // movdqa $-791(%rip), %xmm1 /* LCPI27_4(%rip) */ WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d - WORD $0x3145; BYTE $0xdb // xorl %r11d, %r11d - LONG $0x000029e9; BYTE $0x00 // jmp LBB32_22, $41(%rip) - WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + LONG $0x000023e9; BYTE $0x00 // jmp LBB27_49, $35(%rip) + BYTE $0x90 // .p2align 4, 0x90 -LBB32_24: - WORD $0x3145; BYTE $0xdb // xorl %r11d, %r11d - WORD $0x8548; BYTE $0xc9 // testq %rcx, %rcx - LONG $0x00a5850f; WORD $0x0000 // jne LBB32_81, $165(%rip) - -LBB32_25: - LONG $0x20c48349 // addq $32, %r12 - LONG $0x310c8d4b // leaq (%r9,%r14), %rcx - LONG $0xe0c18348 // addq $-32, %rcx - LONG $0xe0c68349 // addq $-32, %r14 - LONG $0x1ff98348 // cmpq $31, %rcx - LONG $0x0935860f; WORD $0x0000 // jbe LBB32_26, $2357(%rip) - -LBB32_22: - LONG $0x6f0f43f3; WORD $0x2214 // movdqu (%r10,%r12), %xmm2 - LONG $0x6f0f43f3; WORD $0x225c; BYTE $0x10 // movdqu $16(%r10,%r12), %xmm3 +LBB27_51: + WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d + WORD $0xc985 // testl %ecx, %ecx + LONG $0x00a6850f; WORD $0x0000 // jne LBB27_109, $166(%rip) + +LBB27_52: + LONG $0x20c78349 // addq $32, %r15 + LONG $0x294c8d4b; BYTE $0xe0 // leaq $-32(%r9,%r13), %rcx + LONG $0xe0c58349 // addq $-32, %r13 + LONG $0x3ff98348 // cmpq $63, %rcx + LONG $0x09608e0f; WORD $0x0000 // jle LBB27_53, $2400(%rip) + +LBB27_49: + LONG $0x6f0f43f3; WORD $0x3b54; BYTE $0x01 // movdqu $1(%r11,%r15), %xmm2 + LONG $0x6f0f43f3; WORD $0x3b5c; BYTE $0x11 // movdqu $17(%r11,%r15), %xmm3 LONG $0xe26f0f66 // movdqa %xmm2, %xmm4 LONG $0xe0740f66 // pcmpeqb %xmm0, %xmm4 LONG $0xfcd70f66 // pmovmskb %xmm4, %edi @@ -7006,1248 +6809,2147 @@ LBB32_22: LONG $0x10e1c148 // shlq $16, %rcx WORD $0x0948; BYTE $0xf9 // orq %rdi, %rcx LONG $0xd1740f66 // pcmpeqb %xmm1, %xmm2 - LONG $0xf2d70f66 // pmovmskb %xmm2, %esi + LONG $0xdad70f66 // pmovmskb %xmm2, %ebx LONG $0xd9740f66 // pcmpeqb %xmm1, %xmm3 LONG $0xfbd70f66 // pmovmskb %xmm3, %edi LONG $0x10e7c148 // shlq $16, %rdi - WORD $0x0948; BYTE $0xf7 // orq %rsi, %rdi - WORD $0x8948; BYTE $0xfe // movq %rdi, %rsi - WORD $0x094c; BYTE $0xde // orq %r11, %rsi - LONG $0xff8b840f; WORD $0xffff // je LBB32_24, $-117(%rip) - WORD $0x8944; BYTE $0xde // movl %r11d, %esi - WORD $0xd6f7 // notl %esi - WORD $0xfe21 // andl %edi, %esi - LONG $0x363c8d44 // leal (%rsi,%rsi), %r15d - WORD $0x0945; BYTE $0xdf // orl %r11d, %r15d - WORD $0x8944; BYTE $0xfb // movl %r15d, %ebx - WORD $0xd3f7 // notl %ebx - WORD $0xfb21 // andl %edi, %ebx - LONG $0xaaaae381; WORD $0xaaaa // andl $-1431655766, %ebx - WORD $0x3145; BYTE $0xdb // xorl %r11d, %r11d - WORD $0xf301 // addl %esi, %ebx - LONG $0xc3920f41 // setb %r11b - WORD $0xdb01 // addl %ebx, %ebx - LONG $0x5555f381; WORD $0x5555 // xorl $1431655765, %ebx - WORD $0x2144; BYTE $0xfb // andl %r15d, %ebx - WORD $0xd3f7 // notl %ebx - WORD $0xd921 // andl %ebx, %ecx - WORD $0x8548; BYTE $0xc9 // testq %rcx, %rcx - LONG $0xff5b840f; WORD $0xffff // je LBB32_25, $-165(%rip) + WORD $0x0948; BYTE $0xdf // orq %rbx, %rdi + WORD $0x8948; BYTE $0xfb // movq %rdi, %rbx + WORD $0x094c; BYTE $0xe3 // orq %r12, %rbx + LONG $0xff8e840f; WORD $0xffff // je LBB27_51, $-114(%rip) + WORD $0x8944; BYTE $0xe3 // movl %r12d, %ebx + WORD $0x3144; BYTE $0xd3 // xorl %r10d, %ebx + WORD $0xdf21 // andl %ebx, %edi + WORD $0x1c8d; BYTE $0x3f // leal (%rdi,%rdi), %ebx + WORD $0x0944; BYTE $0xe3 // orl %r12d, %ebx + LONG $0xab928d41; WORD $0xaaaa; BYTE $0xaa // leal $-1431655765(%r10), %edx + WORD $0xda31 // xorl %ebx, %edx + WORD $0xfa21 // andl %edi, %edx + LONG $0xaaaae281; WORD $0xaaaa // andl $-1431655766, %edx + WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d + WORD $0xfa01 // addl %edi, %edx + LONG $0xc4920f41 // setb %r12b + WORD $0xd201 // addl %edx, %edx + LONG $0x5555f281; WORD $0x5555 // xorl $1431655765, %edx + WORD $0xda21 // andl %ebx, %edx + WORD $0x3144; BYTE $0xd2 // xorl %r10d, %edx + WORD $0xd121 // andl %edx, %ecx + WORD $0xc985 // testl %ecx, %ecx + LONG $0xff5a840f; WORD $0xffff // je LBB27_52, $-166(%rip) -LBB32_81: - WORD $0xbc0f; BYTE $0xc1 // bsfl %ecx, %eax - WORD $0x0148; BYTE $0xd0 // addq %rdx, %rax - WORD $0x014c; BYTE $0xe0 // addq %r12, %rax - WORD $0xff48; BYTE $0xc0 // incq %rax - LONG $0xfffec8e9; BYTE $0xff // jmp LBB32_15, $-312(%rip) - -LBB32_29: - LONG $0xb845894c // movq %r8, $-72(%rbp) - LONG $0xc86d894c // movq %r13, $-56(%rbp) - LONG $0x084e8b49 // movq $8(%r14), %rcx - WORD $0x2948; BYTE $0xd1 // subq %rdx, %rcx - WORD $0x0349; BYTE $0x16 // addq (%r14), %rdx - QUAD $0x555555555555bb49; WORD $0x5555 // movabsq $6148914691236517205, %r11 - WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d - QUAD $0xfffd36156f0f4466; BYTE $0xff // movdqa $-714(%rip), %xmm10 /* LCPI32_4(%rip) */ - QUAD $0xfffffd1e0d6f0f66 // movdqa $-738(%rip), %xmm1 /* LCPI32_3(%rip) */ +LBB27_109: + LONG $0xc1bc0f48 // bsfq %rcx, %rax + WORD $0x0149; BYTE $0xc3 // addq %rax, %r11 + WORD $0x014d; BYTE $0xfb // addq %r15, %r11 + WORD $0x294d; BYTE $0xc3 // subq %r8, %r11 + LONG $0x02c38349 // addq $2, %r11 + WORD $0x894c; BYTE $0x1e // movq %r11, (%rsi) + LONG $0xfffebfe9; BYTE $0xff // jmp LBB27_43, $-321(%rip) + +LBB27_56: + QUAD $0x555555555555bd49; WORD $0x5555 // movabsq $6148914691236517205, %r13 + LONG $0x084f8b48 // movq $8(%rdi), %rcx + WORD $0x2948; BYTE $0xd9 // subq %rbx, %rcx + WORD $0x0149; BYTE $0xd8 // addq %rbx, %r8 + WORD $0x3145; BYTE $0xff // xorl %r15d, %r15d + QUAD $0xfffbf6156f0f4466; BYTE $0xff // movdqa $-1034(%rip), %xmm10 /* LCPI27_4(%rip) */ + QUAD $0xfffffbde0d6f0f66 // movdqa $-1058(%rip), %xmm1 /* LCPI27_3(%rip) */ LONG $0x760f4566; BYTE $0xc9 // pcmpeqd %xmm9, %xmm9 - QUAD $0xfffffd511d6f0f66 // movdqa $-687(%rip), %xmm3 /* LCPI32_7(%rip) */ - QUAD $0xfffffcf9256f0f66 // movdqa $-775(%rip), %xmm4 /* LCPI32_2(%rip) */ - QUAD $0x333333333333bf49; WORD $0x3333 // movabsq $3689348814741910323, %r15 + QUAD $0xfffffc111d6f0f66 // movdqa $-1007(%rip), %xmm3 /* LCPI27_7(%rip) */ + QUAD $0xfffffbb9256f0f66 // movdqa $-1095(%rip), %xmm4 /* LCPI27_2(%rip) */ LONG $0xc0570f45 // xorps %xmm8, %xmm8 WORD $0x3145; BYTE $0xd2 // xorl %r10d, %r10d - WORD $0x3145; BYTE $0xed // xorl %r13d, %r13d - WORD $0x3145; BYTE $0xc9 // xorl %r9d, %r9d - LONG $0x40f98348 // cmpq $64, %rcx - LONG $0xd04d8948 // movq %rcx, $-48(%rbp) - LONG $0x02748c0f; WORD $0x0000 // jl LBB32_38, $628(%rip) - -LBB32_32: - LONG $0x026f0ff3 // movdqu (%rdx), %xmm0 - LONG $0x6a6f0ff3; BYTE $0x10 // movdqu $16(%rdx), %xmm5 - LONG $0x7a6f0ff3; BYTE $0x20 // movdqu $32(%rdx), %xmm7 - LONG $0x726f0ff3; BYTE $0x30 // movdqu $48(%rdx), %xmm6 - LONG $0xd06f0f66 // movdqa %xmm0, %xmm2 - LONG $0x740f4166; BYTE $0xd2 // pcmpeqb %xmm10, %xmm2 - LONG $0xfad70f66 // pmovmskb %xmm2, %edi - LONG $0xd56f0f66 // movdqa %xmm5, %xmm2 - LONG $0x740f4166; BYTE $0xd2 // pcmpeqb %xmm10, %xmm2 - LONG $0xf2d70f66 // pmovmskb %xmm2, %esi - LONG $0xd76f0f66 // movdqa %xmm7, %xmm2 - LONG $0x740f4166; BYTE $0xd2 // pcmpeqb %xmm10, %xmm2 - LONG $0xcad70f66 // pmovmskb %xmm2, %ecx - LONG $0xd66f0f66 // movdqa %xmm6, %xmm2 - LONG $0x740f4166; BYTE $0xd2 // pcmpeqb %xmm10, %xmm2 - LONG $0xdad70f66 // pmovmskb %xmm2, %ebx - LONG $0x30e3c148 // shlq $48, %rbx - LONG $0x20e1c148 // shlq $32, %rcx - WORD $0x0948; BYTE $0xd9 // orq %rbx, %rcx - LONG $0x10e6c148 // shlq $16, %rsi - WORD $0x0948; BYTE $0xce // orq %rcx, %rsi - WORD $0x0948; BYTE $0xf7 // orq %rsi, %rdi - WORD $0x8948; BYTE $0xf9 // movq %rdi, %rcx - WORD $0x094c; BYTE $0xd1 // orq %r10, %rcx - LONG $0x0012850f; WORD $0x0000 // jne LBB32_34, $18(%rip) - LONG $0xffc7c748; WORD $0xffff; BYTE $0xff // movq $-1, %rdi - WORD $0xc931 // xorl %ecx, %ecx - LONG $0xc04d8948 // movq %rcx, $-64(%rbp) - LONG $0x00003fe9; BYTE $0x00 // jmp LBB32_35, $63(%rip) + WORD $0xd231 // xorl %edx, %edx + LONG $0xc0558948 // movq %rdx, $-64(%rbp) + WORD $0x3145; BYTE $0xdb // xorl %r11d, %r11d + LONG $0x000060e9; BYTE $0x00 // jmp LBB27_58, $96(%rip) + +LBB27_57: + LONG $0x3ff9c149 // sarq $63, %r9 + WORD $0x894c; BYTE $0xf9 // movq %r15, %rcx + WORD $0xd148; BYTE $0xe9 // shrq %rcx + WORD $0x214c; BYTE $0xe9 // andq %r13, %rcx + WORD $0x2949; BYTE $0xcf // subq %rcx, %r15 + WORD $0x894c; BYTE $0xf9 // movq %r15, %rcx + WORD $0x214c; BYTE $0xd1 // andq %r10, %rcx + LONG $0x02efc149 // shrq $2, %r15 + WORD $0x214d; BYTE $0xd7 // andq %r10, %r15 + WORD $0x0149; BYTE $0xcf // addq %rcx, %r15 + WORD $0x894c; BYTE $0xf9 // movq %r15, %rcx + LONG $0x04e9c148 // shrq $4, %rcx + WORD $0x014c; BYTE $0xf9 // addq %r15, %rcx + QUAD $0x0f0f0f0f0f0fba48; WORD $0x0f0f // movabsq $1085102592571150095, %rdx + WORD $0x2148; BYTE $0xd1 // andq %rdx, %rcx + QUAD $0x010101010101ba48; WORD $0x0101 // movabsq $72340172838076673, %rdx + LONG $0xcaaf0f48 // imulq %rdx, %rcx + LONG $0x38e9c148 // shrq $56, %rcx + LONG $0xc04d0148 // addq %rcx, $-64(%rbp) + LONG $0x40c08349 // addq $64, %r8 + LONG $0xd04d8b48 // movq $-48(%rbp), %rcx + LONG $0xc0c18348 // addq $-64, %rcx + WORD $0x894d; BYTE $0xcf // movq %r9, %r15 + LONG $0xc8558b4c // movq $-56(%rbp), %r10 -LBB32_34: +LBB27_58: + LONG $0x40f98348 // cmpq $64, %rcx + LONG $0xd04d8948 // movq %rcx, $-48(%rbp) + LONG $0x02348c0f; WORD $0x0000 // jl LBB27_65, $564(%rip) + +LBB27_59: + LONG $0x6f0f41f3; BYTE $0x00 // movdqu (%r8), %xmm0 + LONG $0x6f0f41f3; WORD $0x1068 // movdqu $16(%r8), %xmm5 + LONG $0x6f0f41f3; WORD $0x2078 // movdqu $32(%r8), %xmm7 + LONG $0x6f0f41f3; WORD $0x3070 // movdqu $48(%r8), %xmm6 + LONG $0xd06f0f66 // movdqa %xmm0, %xmm2 + LONG $0x740f4166; BYTE $0xd2 // pcmpeqb %xmm10, %xmm2 + LONG $0xd2d70f66 // pmovmskb %xmm2, %edx + LONG $0xd56f0f66 // movdqa %xmm5, %xmm2 + LONG $0x740f4166; BYTE $0xd2 // pcmpeqb %xmm10, %xmm2 + LONG $0xd70f4466; BYTE $0xca // pmovmskb %xmm2, %r9d + LONG $0xd76f0f66 // movdqa %xmm7, %xmm2 + LONG $0x740f4166; BYTE $0xd2 // pcmpeqb %xmm10, %xmm2 + LONG $0xdad70f66 // pmovmskb %xmm2, %ebx + LONG $0xd66f0f66 // movdqa %xmm6, %xmm2 + LONG $0x740f4166; BYTE $0xd2 // pcmpeqb %xmm10, %xmm2 + LONG $0xcad70f66 // pmovmskb %xmm2, %ecx + LONG $0x30e1c148 // shlq $48, %rcx + LONG $0x20e3c148 // shlq $32, %rbx + LONG $0x10e1c149 // shlq $16, %r9 + WORD $0x094c; BYTE $0xca // orq %r9, %rdx + WORD $0x0948; BYTE $0xda // orq %rbx, %rdx + WORD $0x0948; BYTE $0xca // orq %rcx, %rdx + WORD $0x8948; BYTE $0xd1 // movq %rdx, %rcx + WORD $0x094c; BYTE $0xd1 // orq %r10, %rcx + LONG $0x0043840f; WORD $0x0000 // je LBB27_61, $67(%rip) WORD $0x894c; BYTE $0xd1 // movq %r10, %rcx WORD $0xf748; BYTE $0xd1 // notq %rcx - WORD $0x2148; BYTE $0xf9 // andq %rdi, %rcx - LONG $0x09048d4c // leaq (%rcx,%rcx), %r8 - WORD $0x094d; BYTE $0xd0 // orq %r10, %r8 - WORD $0x894c; BYTE $0xc6 // movq %r8, %rsi - WORD $0xf748; BYTE $0xd6 // notq %rsi + WORD $0x2148; BYTE $0xd1 // andq %rdx, %rcx + LONG $0x090c8d4c // leaq (%rcx,%rcx), %r9 + WORD $0x094d; BYTE $0xd1 // orq %r10, %r9 + WORD $0x894d; BYTE $0xca // movq %r9, %r10 QUAD $0xaaaaaaaaaaaabb48; WORD $0xaaaa // movabsq $-6148914691236517206, %rbx - WORD $0x2148; BYTE $0xdf // andq %rbx, %rdi - WORD $0x2148; BYTE $0xf7 // andq %rsi, %rdi - WORD $0xf631 // xorl %esi, %esi - WORD $0x0148; BYTE $0xcf // addq %rcx, %rdi - LONG $0xc6920f40 // setb %sil - LONG $0xc0758948 // movq %rsi, $-64(%rbp) - WORD $0x0148; BYTE $0xff // addq %rdi, %rdi - WORD $0x314c; BYTE $0xdf // xorq %r11, %rdi - WORD $0x214c; BYTE $0xc7 // andq %r8, %rdi - WORD $0xf748; BYTE $0xd7 // notq %rdi + WORD $0x3149; BYTE $0xda // xorq %rbx, %r10 + WORD $0x2148; BYTE $0xda // andq %rbx, %rdx + WORD $0x214c; BYTE $0xd2 // andq %r10, %rdx + WORD $0xdb31 // xorl %ebx, %ebx + WORD $0x0148; BYTE $0xca // addq %rcx, %rdx + WORD $0x920f; BYTE $0xc3 // setb %bl + LONG $0xc85d8948 // movq %rbx, $-56(%rbp) + WORD $0x0148; BYTE $0xd2 // addq %rdx, %rdx + WORD $0x314c; BYTE $0xea // xorq %r13, %rdx + WORD $0x214c; BYTE $0xca // andq %r9, %rdx + WORD $0xf748; BYTE $0xd2 // notq %rdx + LONG $0x00000de9; BYTE $0x00 // jmp LBB27_62, $13(%rip) -LBB32_35: - LONG $0xd66f0f66 // movdqa %xmm6, %xmm2 - LONG $0xd1740f66 // pcmpeqb %xmm1, %xmm2 - LONG $0xcad70f66 // pmovmskb %xmm2, %ecx - LONG $0x30e1c148 // shlq $48, %rcx - LONG $0xd76f0f66 // movdqa %xmm7, %xmm2 - LONG $0xd1740f66 // pcmpeqb %xmm1, %xmm2 - LONG $0xf2d70f66 // pmovmskb %xmm2, %esi - LONG $0x20e6c148 // shlq $32, %rsi - WORD $0x0948; BYTE $0xce // orq %rcx, %rsi +LBB27_61: + LONG $0xffc2c748; WORD $0xffff; BYTE $0xff // movq $-1, %rdx + WORD $0xc931 // xorl %ecx, %ecx + LONG $0xc84d8948 // movq %rcx, $-56(%rbp) + +LBB27_62: LONG $0xd56f0f66 // movdqa %xmm5, %xmm2 LONG $0xd1740f66 // pcmpeqb %xmm1, %xmm2 LONG $0xcad70f66 // pmovmskb %xmm2, %ecx LONG $0x10e1c148 // shlq $16, %rcx - WORD $0x0948; BYTE $0xf1 // orq %rsi, %rcx LONG $0xd06f0f66 // movdqa %xmm0, %xmm2 LONG $0xd1740f66 // pcmpeqb %xmm1, %xmm2 - LONG $0xf2d70f66 // pmovmskb %xmm2, %esi - WORD $0x0948; BYTE $0xce // orq %rcx, %rsi - WORD $0x2148; BYTE $0xfe // andq %rdi, %rsi - LONG $0x6e0f4866; BYTE $0xd6 // movq %rsi, %xmm2 + LONG $0xdad70f66 // pmovmskb %xmm2, %ebx + WORD $0x0948; BYTE $0xcb // orq %rcx, %rbx + LONG $0xd76f0f66 // movdqa %xmm7, %xmm2 + LONG $0xd1740f66 // pcmpeqb %xmm1, %xmm2 + LONG $0xcad70f66 // pmovmskb %xmm2, %ecx + LONG $0x20e1c148 // shlq $32, %rcx + WORD $0x0948; BYTE $0xd9 // orq %rbx, %rcx + LONG $0xd66f0f66 // movdqa %xmm6, %xmm2 + LONG $0xd1740f66 // pcmpeqb %xmm1, %xmm2 + LONG $0xdad70f66 // pmovmskb %xmm2, %ebx + LONG $0x30e3c148 // shlq $48, %rbx + WORD $0x0948; BYTE $0xcb // orq %rcx, %rbx + WORD $0x2148; BYTE $0xd3 // andq %rdx, %rbx + LONG $0x6e0f4866; BYTE $0xd3 // movq %rbx, %xmm2 LONG $0x3a0f4166; WORD $0xd144; BYTE $0x00 // pclmulqdq $0, %xmm9, %xmm2 - LONG $0x7e0f4966; BYTE $0xd0 // movq %xmm2, %r8 - WORD $0x314d; BYTE $0xe0 // xorq %r12, %r8 + LONG $0x7e0f4966; BYTE $0xd1 // movq %xmm2, %r9 + WORD $0x314d; BYTE $0xf9 // xorq %r15, %r9 LONG $0xd06f0f66 // movdqa %xmm0, %xmm2 LONG $0xd3740f66 // pcmpeqb %xmm3, %xmm2 - LONG $0xd70f4466; BYTE $0xd2 // pmovmskb %xmm2, %r10d + LONG $0xd70f4466; BYTE $0xfa // pmovmskb %xmm2, %r15d LONG $0xd56f0f66 // movdqa %xmm5, %xmm2 LONG $0xd3740f66 // pcmpeqb %xmm3, %xmm2 - LONG $0xcad70f66 // pmovmskb %xmm2, %ecx + LONG $0xd70f4466; BYTE $0xe2 // pmovmskb %xmm2, %r12d LONG $0xd76f0f66 // movdqa %xmm7, %xmm2 LONG $0xd3740f66 // pcmpeqb %xmm3, %xmm2 - LONG $0xf2d70f66 // pmovmskb %xmm2, %esi + LONG $0xdad70f66 // pmovmskb %xmm2, %ebx LONG $0xd66f0f66 // movdqa %xmm6, %xmm2 LONG $0xd3740f66 // pcmpeqb %xmm3, %xmm2 - LONG $0xfad70f66 // pmovmskb %xmm2, %edi - LONG $0x30e7c148 // shlq $48, %rdi - LONG $0x20e6c148 // shlq $32, %rsi - WORD $0x0948; BYTE $0xfe // orq %rdi, %rsi - LONG $0x10e1c148 // shlq $16, %rcx - WORD $0x0948; BYTE $0xf1 // orq %rsi, %rcx - WORD $0x0949; BYTE $0xca // orq %rcx, %r10 - WORD $0x894d; BYTE $0xc4 // movq %r8, %r12 - WORD $0xf749; BYTE $0xd4 // notq %r12 - WORD $0x214d; BYTE $0xe2 // andq %r12, %r10 + LONG $0xcad70f66 // pmovmskb %xmm2, %ecx + LONG $0x30e1c148 // shlq $48, %rcx + LONG $0x20e3c148 // shlq $32, %rbx + LONG $0x10e4c149 // shlq $16, %r12 + WORD $0x094d; BYTE $0xe7 // orq %r12, %r15 + WORD $0x0949; BYTE $0xdf // orq %rbx, %r15 + WORD $0x0949; BYTE $0xcf // orq %rcx, %r15 + WORD $0x894c; BYTE $0xc9 // movq %r9, %rcx + WORD $0xf748; BYTE $0xd1 // notq %rcx + WORD $0x2149; BYTE $0xcf // andq %rcx, %r15 LONG $0xc4740f66 // pcmpeqb %xmm4, %xmm0 - LONG $0xf8d70f66 // pmovmskb %xmm0, %edi + LONG $0xd70f4466; BYTE $0xe0 // pmovmskb %xmm0, %r12d LONG $0xec740f66 // pcmpeqb %xmm4, %xmm5 - LONG $0xcdd70f66 // pmovmskb %xmm5, %ecx + LONG $0xddd70f66 // pmovmskb %xmm5, %ebx LONG $0xfc740f66 // pcmpeqb %xmm4, %xmm7 - LONG $0xdfd70f66 // pmovmskb %xmm7, %ebx + LONG $0xd70f4466; BYTE $0xd7 // pmovmskb %xmm7, %r10d LONG $0xf4740f66 // pcmpeqb %xmm4, %xmm6 - LONG $0xf6d70f66 // pmovmskb %xmm6, %esi - LONG $0x30e6c148 // shlq $48, %rsi - LONG $0x20e3c148 // shlq $32, %rbx - WORD $0x0948; BYTE $0xf3 // orq %rsi, %rbx - LONG $0x10e1c148 // shlq $16, %rcx - WORD $0x0948; BYTE $0xd9 // orq %rbx, %rcx - WORD $0x0948; BYTE $0xcf // orq %rcx, %rdi - QUAD $0x0f0f0f0f0f0fbb48; WORD $0x0f0f // movabsq $1085102592571150095, %rbx - WORD $0x214c; BYTE $0xe7 // andq %r12, %rdi - LONG $0x0065840f; WORD $0x0000 // je LBB32_30, $101(%rip) + LONG $0xd70f4466; BYTE $0xee // pmovmskb %xmm6, %r13d + LONG $0x30e5c149 // shlq $48, %r13 + LONG $0x20e2c149 // shlq $32, %r10 + LONG $0x10e3c148 // shlq $16, %rbx + WORD $0x0949; BYTE $0xdc // orq %rbx, %r12 + WORD $0x094d; BYTE $0xd4 // orq %r10, %r12 + WORD $0x094d; BYTE $0xec // orq %r13, %r12 + QUAD $0x555555555555bd49; WORD $0x5555 // movabsq $6148914691236517205, %r13 + QUAD $0x333333333333ba49; WORD $0x3333 // movabsq $3689348814741910323, %r10 + WORD $0x2149; BYTE $0xcc // andq %rcx, %r12 + LONG $0xfdd4840f; WORD $0xffff // je LBB27_57, $-556(%rip) QUAD $0x9090909090909090 // .p2align 4, 0x90 -LBB32_36: - LONG $0xff678d4c // leaq $-1(%rdi), %r12 - WORD $0x894c; BYTE $0xe1 // movq %r12, %rcx - WORD $0x214c; BYTE $0xd1 // andq %r10, %rcx - WORD $0x8948; BYTE $0xce // movq %rcx, %rsi - WORD $0xd148; BYTE $0xee // shrq %rsi - WORD $0x214c; BYTE $0xde // andq %r11, %rsi - WORD $0x2948; BYTE $0xf1 // subq %rsi, %rcx - WORD $0x8948; BYTE $0xce // movq %rcx, %rsi - WORD $0x214c; BYTE $0xfe // andq %r15, %rsi - LONG $0x02e9c148 // shrq $2, %rcx - WORD $0x214c; BYTE $0xf9 // andq %r15, %rcx - WORD $0x0148; BYTE $0xf1 // addq %rsi, %rcx - WORD $0x8948; BYTE $0xce // movq %rcx, %rsi - LONG $0x04eec148 // shrq $4, %rsi - WORD $0x0148; BYTE $0xce // addq %rcx, %rsi - WORD $0x2148; BYTE $0xde // andq %rbx, %rsi - QUAD $0x010101010101b948; WORD $0x0101 // movabsq $72340172838076673, %rcx - LONG $0xf1af0f48 // imulq %rcx, %rsi - LONG $0x38eec148 // shrq $56, %rsi - WORD $0x014c; BYTE $0xee // addq %r13, %rsi - WORD $0x394c; BYTE $0xce // cmpq %r9, %rsi - LONG $0x05dd860f; WORD $0x0000 // jbe LBB32_80, $1501(%rip) - WORD $0xff49; BYTE $0xc1 // incq %r9 - WORD $0x214c; BYTE $0xe7 // andq %r12, %rdi - LONG $0xffa3850f; WORD $0xffff // jne LBB32_36, $-93(%rip) - -LBB32_30: - LONG $0x3ff8c149 // sarq $63, %r8 - WORD $0x894c; BYTE $0xd1 // movq %r10, %rcx +LBB27_63: + LONG $0x24548d49; BYTE $0xff // leaq $-1(%r12), %rdx + WORD $0x8948; BYTE $0xd3 // movq %rdx, %rbx + WORD $0x214c; BYTE $0xfb // andq %r15, %rbx + WORD $0x8948; BYTE $0xd9 // movq %rbx, %rcx WORD $0xd148; BYTE $0xe9 // shrq %rcx - WORD $0x214c; BYTE $0xd9 // andq %r11, %rcx - WORD $0x2949; BYTE $0xca // subq %rcx, %r10 - WORD $0x894c; BYTE $0xd1 // movq %r10, %rcx - WORD $0x214c; BYTE $0xf9 // andq %r15, %rcx - LONG $0x02eac149 // shrq $2, %r10 - WORD $0x214d; BYTE $0xfa // andq %r15, %r10 - WORD $0x0149; BYTE $0xca // addq %rcx, %r10 - WORD $0x894c; BYTE $0xd1 // movq %r10, %rcx + WORD $0x214c; BYTE $0xe9 // andq %r13, %rcx + WORD $0x2948; BYTE $0xcb // subq %rcx, %rbx + WORD $0x8948; BYTE $0xd9 // movq %rbx, %rcx + WORD $0x214c; BYTE $0xd1 // andq %r10, %rcx + LONG $0x02ebc148 // shrq $2, %rbx + WORD $0x214c; BYTE $0xd3 // andq %r10, %rbx + WORD $0x0148; BYTE $0xcb // addq %rcx, %rbx + WORD $0x8948; BYTE $0xd9 // movq %rbx, %rcx LONG $0x04e9c148 // shrq $4, %rcx - WORD $0x014c; BYTE $0xd1 // addq %r10, %rcx + WORD $0x0148; BYTE $0xd9 // addq %rbx, %rcx + QUAD $0x0f0f0f0f0f0fbb48; WORD $0x0f0f // movabsq $1085102592571150095, %rbx WORD $0x2148; BYTE $0xd9 // andq %rbx, %rcx - QUAD $0x010101010101be48; WORD $0x0101 // movabsq $72340172838076673, %rsi - LONG $0xceaf0f48 // imulq %rsi, %rcx + QUAD $0x010101010101bb48; WORD $0x0101 // movabsq $72340172838076673, %rbx + LONG $0xcbaf0f48 // imulq %rbx, %rcx LONG $0x38e9c148 // shrq $56, %rcx - WORD $0x0149; BYTE $0xcd // addq %rcx, %r13 - LONG $0x40c28348 // addq $64, %rdx - LONG $0xd04d8b48 // movq $-48(%rbp), %rcx - LONG $0xc0c18348 // addq $-64, %rcx - WORD $0x894d; BYTE $0xc4 // movq %r8, %r12 - LONG $0xc0558b4c // movq $-64(%rbp), %r10 - LONG $0x40f98348 // cmpq $64, %rcx - LONG $0xd04d8948 // movq %rcx, $-48(%rbp) - LONG $0xfd8c8d0f; WORD $0xffff // jge LBB32_32, $-628(%rip) + LONG $0xc04d0348 // addq $-64(%rbp), %rcx + WORD $0x394c; BYTE $0xd9 // cmpq %r11, %rcx + LONG $0x05a3860f; WORD $0x0000 // jbe LBB27_108, $1443(%rip) + WORD $0xff49; BYTE $0xc3 // incq %r11 + WORD $0x2149; BYTE $0xd4 // andq %rdx, %r12 + LONG $0xff97850f; WORD $0xffff // jne LBB27_63, $-105(%rip) + LONG $0xfffd5ee9; BYTE $0xff // jmp LBB27_57, $-674(%rip) -LBB32_38: +LBB27_65: WORD $0x8548; BYTE $0xc9 // testq %rcx, %rcx - LONG $0x05e08e0f; WORD $0x0000 // jle LBB32_85, $1504(%rip) - WORD $0x894c; BYTE $0xd7 // movq %r10, %rdi + LONG $0x06468e0f; WORD $0x0000 // jle LBB27_117, $1606(%rip) + WORD $0x894c; BYTE $0xd3 // movq %r10, %rbx + LONG $0x45110f44; BYTE $0xb0 // movups %xmm8, $-80(%rbp) LONG $0x45110f44; BYTE $0xa0 // movups %xmm8, $-96(%rbp) LONG $0x45110f44; BYTE $0x90 // movups %xmm8, $-112(%rbp) LONG $0x45110f44; BYTE $0x80 // movups %xmm8, $-128(%rbp) - QUAD $0xffffff7085110f44 // movups %xmm8, $-144(%rbp) - WORD $0xd189 // movl %edx, %ecx + WORD $0x8944; BYTE $0xc1 // movl %r8d, %ecx LONG $0x0fffe181; WORD $0x0000 // andl $4095, %ecx LONG $0x0fc1f981; WORD $0x0000 // cmpl $4033, %ecx - LONG $0x0036820f; WORD $0x0000 // jb LBB32_42, $54(%rip) + LONG $0x0031820f; WORD $0x0000 // jb LBB27_69, $49(%rip) LONG $0xd07d8348; BYTE $0x20 // cmpq $32, $-48(%rbp) - LONG $0x0033820f; WORD $0x0000 // jb LBB32_43, $51(%rip) - LONG $0x026f0ff3 // movdqu (%rdx), %xmm0 - LONG $0x526f0ff3; BYTE $0x10 // movdqu $16(%rdx), %xmm2 - QUAD $0xffffff70857f0ff3 // movdqu %xmm0, $-144(%rbp) - LONG $0x557f0ff3; BYTE $0x80 // movdqu %xmm2, $-128(%rbp) - LONG $0x20c28348 // addq $32, %rdx + LONG $0x0038820f; WORD $0x0000 // jb LBB27_70, $56(%rip) + LONG $0x00100f41 // movups (%r8), %xmm0 + LONG $0x8045110f // movups %xmm0, $-128(%rbp) + LONG $0x40100f41; BYTE $0x10 // movups $16(%r8), %xmm0 + LONG $0x9045110f // movups %xmm0, $-112(%rbp) + LONG $0x20c08349 // addq $32, %r8 LONG $0xd04d8b48 // movq $-48(%rbp), %rcx - LONG $0xe0518d4c // leaq $-32(%rcx), %r10 - LONG $0x90458d4c // leaq $-112(%rbp), %r8 - LONG $0x000013e9; BYTE $0x00 // jmp LBB32_44, $19(%rip) + LONG $0xe0518d48 // leaq $-32(%rcx), %rdx + LONG $0xa04d8d4c // leaq $-96(%rbp), %r9 + LONG $0x00001ae9; BYTE $0x00 // jmp LBB27_71, $26(%rip) -LBB32_42: - WORD $0x8949; BYTE $0xfa // movq %rdi, %r10 - LONG $0xfffd17e9; BYTE $0xff // jmp LBB32_32, $-745(%rip) +LBB27_69: + QUAD $0x555555555555bd49; WORD $0x5555 // movabsq $6148914691236517205, %r13 + WORD $0x8949; BYTE $0xda // movq %rbx, %r10 + LONG $0xfffd54e9; BYTE $0xff // jmp LBB27_59, $-684(%rip) -LBB32_43: - LONG $0x70858d4c; WORD $0xffff; BYTE $0xff // leaq $-144(%rbp), %r8 - LONG $0xd0558b4c // movq $-48(%rbp), %r10 +LBB27_70: + LONG $0x804d8d4c // leaq $-128(%rbp), %r9 + LONG $0xd0558b48 // movq $-48(%rbp), %rdx -LBB32_44: - LONG $0x10fa8349 // cmpq $16, %r10 - LONG $0x0049820f; WORD $0x0000 // jb LBB32_45, $73(%rip) - LONG $0x026f0ff3 // movdqu (%rdx), %xmm0 - LONG $0x7f0f41f3; BYTE $0x00 // movdqu %xmm0, (%r8) - LONG $0x10c28348 // addq $16, %rdx +LBB27_71: + LONG $0x10fa8348 // cmpq $16, %rdx + LONG $0x0049820f; WORD $0x0000 // jb LBB27_72, $73(%rip) + LONG $0x00100f41 // movups (%r8), %xmm0 + LONG $0x01110f41 // movups %xmm0, (%r9) LONG $0x10c08349 // addq $16, %r8 - LONG $0xf0c28349 // addq $-16, %r10 - LONG $0x08fa8349 // cmpq $8, %r10 - LONG $0x0034830f; WORD $0x0000 // jae LBB32_52, $52(%rip) + LONG $0x10c18349 // addq $16, %r9 + LONG $0xf0c28348 // addq $-16, %rdx + LONG $0x08fa8348 // cmpq $8, %rdx + LONG $0x0035830f; WORD $0x0000 // jae LBB27_79, $53(%rip) -LBB32_46: - LONG $0x04fa8349 // cmpq $4, %r10 - LONG $0x0046820f; WORD $0x0000 // jb LBB32_47, $70(%rip) +LBB27_73: + LONG $0x04fa8348 // cmpq $4, %rdx + LONG $0x00478c0f; WORD $0x0000 // jl LBB27_74, $71(%rip) -LBB32_53: - WORD $0x0a8b // movl (%rdx), %ecx - WORD $0x8941; BYTE $0x08 // movl %ecx, (%r8) - LONG $0x04c28348 // addq $4, %rdx +LBB27_80: + WORD $0x8b41; BYTE $0x08 // movl (%r8), %ecx + WORD $0x8941; BYTE $0x09 // movl %ecx, (%r9) LONG $0x04c08349 // addq $4, %r8 - LONG $0xfcc28349 // addq $-4, %r10 - LONG $0x02fa8349 // cmpq $2, %r10 - LONG $0x0035830f; WORD $0x0000 // jae LBB32_48, $53(%rip) - LONG $0x000043e9; BYTE $0x00 // jmp LBB32_49, $67(%rip) + LONG $0x04c18349 // addq $4, %r9 + LONG $0xfcc28348 // addq $-4, %rdx + LONG $0x02fa8348 // cmpq $2, %rdx + LONG $0x0035830f; WORD $0x0000 // jae LBB27_75, $53(%rip) + LONG $0x000044e9; BYTE $0x00 // jmp LBB27_76, $68(%rip) -LBB32_45: - LONG $0x08fa8349 // cmpq $8, %r10 - LONG $0xffcc820f; WORD $0xffff // jb LBB32_46, $-52(%rip) +LBB27_72: + LONG $0x08fa8348 // cmpq $8, %rdx + LONG $0xffcb820f; WORD $0xffff // jb LBB27_73, $-53(%rip) -LBB32_52: - WORD $0x8b48; BYTE $0x0a // movq (%rdx), %rcx - WORD $0x8949; BYTE $0x08 // movq %rcx, (%r8) - LONG $0x08c28348 // addq $8, %rdx +LBB27_79: + WORD $0x8b49; BYTE $0x08 // movq (%r8), %rcx + WORD $0x8949; BYTE $0x09 // movq %rcx, (%r9) LONG $0x08c08349 // addq $8, %r8 - LONG $0xf8c28349 // addq $-8, %r10 - LONG $0x04fa8349 // cmpq $4, %r10 - LONG $0xffba830f; WORD $0xffff // jae LBB32_53, $-70(%rip) + LONG $0x08c18349 // addq $8, %r9 + LONG $0xf8c28348 // addq $-8, %rdx + LONG $0x04fa8348 // cmpq $4, %rdx + LONG $0xffb98d0f; WORD $0xffff // jge LBB27_80, $-71(%rip) -LBB32_47: - LONG $0x02fa8349 // cmpq $2, %r10 - LONG $0x0013820f; WORD $0x0000 // jb LBB32_49, $19(%rip) +LBB27_74: + LONG $0x02fa8348 // cmpq $2, %rdx + LONG $0x0014820f; WORD $0x0000 // jb LBB27_76, $20(%rip) -LBB32_48: - WORD $0xb70f; BYTE $0x0a // movzwl (%rdx), %ecx - LONG $0x08894166 // movw %cx, (%r8) - LONG $0x02c28348 // addq $2, %rdx - LONG $0x02c08349 // addq $2, %r8 - LONG $0xfec28349 // addq $-2, %r10 +LBB27_75: + LONG $0x08b70f41 // movzwl (%r8), %ecx + LONG $0x09894166 // movw %cx, (%r9) + LONG $0x02c08349 // addq $2, %r8 + LONG $0x02c18349 // addq $2, %r9 + LONG $0xfec28348 // addq $-2, %rdx -LBB32_49: - WORD $0x8948; BYTE $0xd6 // movq %rdx, %rsi - LONG $0x70958d48; WORD $0xffff; BYTE $0xff // leaq $-144(%rbp), %rdx - WORD $0x854d; BYTE $0xd2 // testq %r10, %r10 - WORD $0x8949; BYTE $0xfa // movq %rdi, %r10 - LONG $0xfc60840f; WORD $0xffff // je LBB32_32, $-928(%rip) - WORD $0xb60f; BYTE $0x0e // movzbl (%rsi), %ecx - WORD $0x8841; BYTE $0x08 // movb %cl, (%r8) - LONG $0x70958d48; WORD $0xffff; BYTE $0xff // leaq $-144(%rbp), %rdx - LONG $0xfffc4ee9; BYTE $0xff // jmp LBB32_32, $-946(%rip) - -LBB32_54: - LONG $0x04c28348 // addq $4, %rdx - LONG $0x08563b49 // cmpq $8(%r14), %rdx - LONG $0xfaa5830f; WORD $0xffff // jae LBB32_17, $-1371(%rip) - LONG $0x000461e9; BYTE $0x00 // jmp LBB32_83, $1121(%rip) - -LBB32_55: - LONG $0xb845894c // movq %r8, $-72(%rbp) - LONG $0xc86d894c // movq %r13, $-56(%rbp) - LONG $0x084e8b49 // movq $8(%r14), %rcx - WORD $0x2948; BYTE $0xd1 // subq %rdx, %rcx - WORD $0x0349; BYTE $0x16 // addq (%r14), %rdx - QUAD $0x555555555555bb49; WORD $0x5555 // movabsq $6148914691236517205, %r11 - WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d - QUAD $0xfff907156f0f4466; BYTE $0xff // movdqa $-1785(%rip), %xmm10 /* LCPI32_4(%rip) */ - QUAD $0xfffff8ef0d6f0f66 // movdqa $-1809(%rip), %xmm1 /* LCPI32_3(%rip) */ +LBB27_76: + WORD $0x894c; BYTE $0xc1 // movq %r8, %rcx + LONG $0x80458d4c // leaq $-128(%rbp), %r8 + WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx + QUAD $0x555555555555bd49; WORD $0x5555 // movabsq $6148914691236517205, %r13 + WORD $0x8949; BYTE $0xda // movq %rbx, %r10 + LONG $0xfc98840f; WORD $0xffff // je LBB27_59, $-872(%rip) + WORD $0x098a // movb (%rcx), %cl + WORD $0x8841; BYTE $0x09 // movb %cl, (%r9) + LONG $0x80458d4c // leaq $-128(%rbp), %r8 + LONG $0xfffc8ae9; BYTE $0xff // jmp LBB27_59, $-886(%rip) + +LBB27_81: + LONG $0x054e8d49 // leaq $5(%r14), %rcx + LONG $0x084f3b48 // cmpq $8(%rdi), %rcx + LONG $0xfa7e870f; WORD $0xffff // ja LBB27_44, $-1410(%rip) + +LBB27_82: + WORD $0x8948; BYTE $0x0e // movq %rcx, (%rsi) + LONG $0xfffa73e9; BYTE $0xff // jmp LBB27_43, $-1421(%rip) + +LBB27_83: + QUAD $0x555555555555bd49; WORD $0x5555 // movabsq $6148914691236517205, %r13 + LONG $0x084f8b48 // movq $8(%rdi), %rcx + WORD $0x2948; BYTE $0xd9 // subq %rbx, %rcx + WORD $0x0149; BYTE $0xd8 // addq %rbx, %r8 + WORD $0x3145; BYTE $0xff // xorl %r15d, %r15d + QUAD $0xfff7aa156f0f4466; BYTE $0xff // movdqa $-2134(%rip), %xmm10 /* LCPI27_4(%rip) */ + QUAD $0xfffff7920d6f0f66 // movdqa $-2158(%rip), %xmm1 /* LCPI27_3(%rip) */ LONG $0x760f4566; BYTE $0xc9 // pcmpeqd %xmm9, %xmm9 - QUAD $0xfffff9021d6f0f66 // movdqa $-1790(%rip), %xmm3 /* LCPI32_5(%rip) */ - QUAD $0xfffff90a256f0f66 // movdqa $-1782(%rip), %xmm4 /* LCPI32_6(%rip) */ - QUAD $0x333333333333bf49; WORD $0x3333 // movabsq $3689348814741910323, %r15 + QUAD $0xfffff7a51d6f0f66 // movdqa $-2139(%rip), %xmm3 /* LCPI27_5(%rip) */ + QUAD $0xfffff7ad256f0f66 // movdqa $-2131(%rip), %xmm4 /* LCPI27_6(%rip) */ LONG $0xc0570f45 // xorps %xmm8, %xmm8 WORD $0x3145; BYTE $0xd2 // xorl %r10d, %r10d - WORD $0x3145; BYTE $0xed // xorl %r13d, %r13d - WORD $0x3145; BYTE $0xc9 // xorl %r9d, %r9d - LONG $0x40f98348 // cmpq $64, %rcx - LONG $0xd04d8948 // movq %rcx, $-48(%rbp) - LONG $0x02758c0f; WORD $0x0000 // jl LBB32_64, $629(%rip) - -LBB32_58: - LONG $0x026f0ff3 // movdqu (%rdx), %xmm0 - LONG $0x6a6f0ff3; BYTE $0x10 // movdqu $16(%rdx), %xmm5 - LONG $0x7a6f0ff3; BYTE $0x20 // movdqu $32(%rdx), %xmm7 - LONG $0x726f0ff3; BYTE $0x30 // movdqu $48(%rdx), %xmm6 - LONG $0xd06f0f66 // movdqa %xmm0, %xmm2 - LONG $0x740f4166; BYTE $0xd2 // pcmpeqb %xmm10, %xmm2 - LONG $0xfad70f66 // pmovmskb %xmm2, %edi - LONG $0xd56f0f66 // movdqa %xmm5, %xmm2 - LONG $0x740f4166; BYTE $0xd2 // pcmpeqb %xmm10, %xmm2 - LONG $0xf2d70f66 // pmovmskb %xmm2, %esi - LONG $0xd76f0f66 // movdqa %xmm7, %xmm2 - LONG $0x740f4166; BYTE $0xd2 // pcmpeqb %xmm10, %xmm2 - LONG $0xdad70f66 // pmovmskb %xmm2, %ebx - LONG $0xd66f0f66 // movdqa %xmm6, %xmm2 - LONG $0x740f4166; BYTE $0xd2 // pcmpeqb %xmm10, %xmm2 - LONG $0xcad70f66 // pmovmskb %xmm2, %ecx - LONG $0x30e1c148 // shlq $48, %rcx - LONG $0x20e3c148 // shlq $32, %rbx - WORD $0x0948; BYTE $0xcb // orq %rcx, %rbx - LONG $0x10e6c148 // shlq $16, %rsi - WORD $0x0948; BYTE $0xde // orq %rbx, %rsi - WORD $0x0948; BYTE $0xf7 // orq %rsi, %rdi - WORD $0x8948; BYTE $0xf9 // movq %rdi, %rcx - WORD $0x094c; BYTE $0xd1 // orq %r10, %rcx - LONG $0x0012850f; WORD $0x0000 // jne LBB32_60, $18(%rip) - LONG $0xffc7c748; WORD $0xffff; BYTE $0xff // movq $-1, %rdi - WORD $0xc931 // xorl %ecx, %ecx - LONG $0xc04d8948 // movq %rcx, $-64(%rbp) - LONG $0x00003fe9; BYTE $0x00 // jmp LBB32_61, $63(%rip) + WORD $0xd231 // xorl %edx, %edx + LONG $0xc0558948 // movq %rdx, $-64(%rbp) + WORD $0x3145; BYTE $0xdb // xorl %r11d, %r11d + LONG $0x000060e9; BYTE $0x00 // jmp LBB27_85, $96(%rip) + +LBB27_84: + LONG $0x3ff9c149 // sarq $63, %r9 + WORD $0x894c; BYTE $0xf9 // movq %r15, %rcx + WORD $0xd148; BYTE $0xe9 // shrq %rcx + WORD $0x214c; BYTE $0xe9 // andq %r13, %rcx + WORD $0x2949; BYTE $0xcf // subq %rcx, %r15 + WORD $0x894c; BYTE $0xf9 // movq %r15, %rcx + WORD $0x214c; BYTE $0xd1 // andq %r10, %rcx + LONG $0x02efc149 // shrq $2, %r15 + WORD $0x214d; BYTE $0xd7 // andq %r10, %r15 + WORD $0x0149; BYTE $0xcf // addq %rcx, %r15 + WORD $0x894c; BYTE $0xf9 // movq %r15, %rcx + LONG $0x04e9c148 // shrq $4, %rcx + WORD $0x014c; BYTE $0xf9 // addq %r15, %rcx + QUAD $0x0f0f0f0f0f0fba48; WORD $0x0f0f // movabsq $1085102592571150095, %rdx + WORD $0x2148; BYTE $0xd1 // andq %rdx, %rcx + QUAD $0x010101010101ba48; WORD $0x0101 // movabsq $72340172838076673, %rdx + LONG $0xcaaf0f48 // imulq %rdx, %rcx + LONG $0x38e9c148 // shrq $56, %rcx + LONG $0xc04d0148 // addq %rcx, $-64(%rbp) + LONG $0x40c08349 // addq $64, %r8 + LONG $0xd04d8b48 // movq $-48(%rbp), %rcx + LONG $0xc0c18348 // addq $-64, %rcx + WORD $0x894d; BYTE $0xcf // movq %r9, %r15 + LONG $0xc8558b4c // movq $-56(%rbp), %r10 -LBB32_60: +LBB27_85: + LONG $0x40f98348 // cmpq $64, %rcx + LONG $0xd04d8948 // movq %rcx, $-48(%rbp) + LONG $0x02388c0f; WORD $0x0000 // jl LBB27_92, $568(%rip) + +LBB27_86: + LONG $0x6f0f41f3; BYTE $0x00 // movdqu (%r8), %xmm0 + LONG $0x6f0f41f3; WORD $0x1068 // movdqu $16(%r8), %xmm5 + LONG $0x6f0f41f3; WORD $0x2078 // movdqu $32(%r8), %xmm7 + LONG $0x6f0f41f3; WORD $0x3070 // movdqu $48(%r8), %xmm6 + LONG $0xd06f0f66 // movdqa %xmm0, %xmm2 + LONG $0x740f4166; BYTE $0xd2 // pcmpeqb %xmm10, %xmm2 + LONG $0xd2d70f66 // pmovmskb %xmm2, %edx + LONG $0xd56f0f66 // movdqa %xmm5, %xmm2 + LONG $0x740f4166; BYTE $0xd2 // pcmpeqb %xmm10, %xmm2 + LONG $0xd70f4466; BYTE $0xca // pmovmskb %xmm2, %r9d + LONG $0xd76f0f66 // movdqa %xmm7, %xmm2 + LONG $0x740f4166; BYTE $0xd2 // pcmpeqb %xmm10, %xmm2 + LONG $0xdad70f66 // pmovmskb %xmm2, %ebx + LONG $0xd66f0f66 // movdqa %xmm6, %xmm2 + LONG $0x740f4166; BYTE $0xd2 // pcmpeqb %xmm10, %xmm2 + LONG $0xcad70f66 // pmovmskb %xmm2, %ecx + LONG $0x30e1c148 // shlq $48, %rcx + LONG $0x20e3c148 // shlq $32, %rbx + LONG $0x10e1c149 // shlq $16, %r9 + WORD $0x094c; BYTE $0xca // orq %r9, %rdx + WORD $0x0948; BYTE $0xda // orq %rbx, %rdx + WORD $0x0948; BYTE $0xca // orq %rcx, %rdx + WORD $0x8948; BYTE $0xd1 // movq %rdx, %rcx + WORD $0x094c; BYTE $0xd1 // orq %r10, %rcx + LONG $0x0043840f; WORD $0x0000 // je LBB27_88, $67(%rip) WORD $0x894c; BYTE $0xd1 // movq %r10, %rcx WORD $0xf748; BYTE $0xd1 // notq %rcx - WORD $0x2148; BYTE $0xf9 // andq %rdi, %rcx - LONG $0x09048d4c // leaq (%rcx,%rcx), %r8 - WORD $0x094d; BYTE $0xd0 // orq %r10, %r8 - WORD $0x894c; BYTE $0xc6 // movq %r8, %rsi - WORD $0xf748; BYTE $0xd6 // notq %rsi + WORD $0x2148; BYTE $0xd1 // andq %rdx, %rcx + LONG $0x090c8d4c // leaq (%rcx,%rcx), %r9 + WORD $0x094d; BYTE $0xd1 // orq %r10, %r9 + WORD $0x894d; BYTE $0xca // movq %r9, %r10 QUAD $0xaaaaaaaaaaaabb48; WORD $0xaaaa // movabsq $-6148914691236517206, %rbx - WORD $0x2148; BYTE $0xdf // andq %rbx, %rdi - WORD $0x2148; BYTE $0xf7 // andq %rsi, %rdi - WORD $0xf631 // xorl %esi, %esi - WORD $0x0148; BYTE $0xcf // addq %rcx, %rdi - LONG $0xc6920f40 // setb %sil - LONG $0xc0758948 // movq %rsi, $-64(%rbp) - WORD $0x0148; BYTE $0xff // addq %rdi, %rdi - WORD $0x314c; BYTE $0xdf // xorq %r11, %rdi - WORD $0x214c; BYTE $0xc7 // andq %r8, %rdi - WORD $0xf748; BYTE $0xd7 // notq %rdi + WORD $0x3149; BYTE $0xda // xorq %rbx, %r10 + WORD $0x2148; BYTE $0xda // andq %rbx, %rdx + WORD $0x214c; BYTE $0xd2 // andq %r10, %rdx + WORD $0xdb31 // xorl %ebx, %ebx + WORD $0x0148; BYTE $0xca // addq %rcx, %rdx + WORD $0x920f; BYTE $0xc3 // setb %bl + LONG $0xc85d8948 // movq %rbx, $-56(%rbp) + WORD $0x0148; BYTE $0xd2 // addq %rdx, %rdx + WORD $0x314c; BYTE $0xea // xorq %r13, %rdx + WORD $0x214c; BYTE $0xca // andq %r9, %rdx + WORD $0xf748; BYTE $0xd2 // notq %rdx + LONG $0x00000de9; BYTE $0x00 // jmp LBB27_89, $13(%rip) -LBB32_61: - LONG $0xd66f0f66 // movdqa %xmm6, %xmm2 - LONG $0xd1740f66 // pcmpeqb %xmm1, %xmm2 - LONG $0xcad70f66 // pmovmskb %xmm2, %ecx - LONG $0x30e1c148 // shlq $48, %rcx - LONG $0xd76f0f66 // movdqa %xmm7, %xmm2 - LONG $0xd1740f66 // pcmpeqb %xmm1, %xmm2 - LONG $0xf2d70f66 // pmovmskb %xmm2, %esi - LONG $0x20e6c148 // shlq $32, %rsi - WORD $0x0948; BYTE $0xce // orq %rcx, %rsi +LBB27_88: + LONG $0xffc2c748; WORD $0xffff; BYTE $0xff // movq $-1, %rdx + WORD $0xc931 // xorl %ecx, %ecx + LONG $0xc84d8948 // movq %rcx, $-56(%rbp) + +LBB27_89: LONG $0xd56f0f66 // movdqa %xmm5, %xmm2 LONG $0xd1740f66 // pcmpeqb %xmm1, %xmm2 LONG $0xcad70f66 // pmovmskb %xmm2, %ecx LONG $0x10e1c148 // shlq $16, %rcx - WORD $0x0948; BYTE $0xf1 // orq %rsi, %rcx LONG $0xd06f0f66 // movdqa %xmm0, %xmm2 LONG $0xd1740f66 // pcmpeqb %xmm1, %xmm2 - LONG $0xf2d70f66 // pmovmskb %xmm2, %esi - WORD $0x0948; BYTE $0xce // orq %rcx, %rsi - WORD $0x2148; BYTE $0xfe // andq %rdi, %rsi - LONG $0x6e0f4866; BYTE $0xd6 // movq %rsi, %xmm2 + LONG $0xdad70f66 // pmovmskb %xmm2, %ebx + WORD $0x0948; BYTE $0xcb // orq %rcx, %rbx + LONG $0xd76f0f66 // movdqa %xmm7, %xmm2 + LONG $0xd1740f66 // pcmpeqb %xmm1, %xmm2 + LONG $0xcad70f66 // pmovmskb %xmm2, %ecx + LONG $0x20e1c148 // shlq $32, %rcx + WORD $0x0948; BYTE $0xd9 // orq %rbx, %rcx + LONG $0xd66f0f66 // movdqa %xmm6, %xmm2 + LONG $0xd1740f66 // pcmpeqb %xmm1, %xmm2 + LONG $0xdad70f66 // pmovmskb %xmm2, %ebx + LONG $0x30e3c148 // shlq $48, %rbx + WORD $0x0948; BYTE $0xcb // orq %rcx, %rbx + WORD $0x2148; BYTE $0xd3 // andq %rdx, %rbx + LONG $0x6e0f4866; BYTE $0xd3 // movq %rbx, %xmm2 LONG $0x3a0f4166; WORD $0xd144; BYTE $0x00 // pclmulqdq $0, %xmm9, %xmm2 - LONG $0x7e0f4966; BYTE $0xd0 // movq %xmm2, %r8 - WORD $0x314d; BYTE $0xe0 // xorq %r12, %r8 + LONG $0x7e0f4966; BYTE $0xd1 // movq %xmm2, %r9 + WORD $0x314d; BYTE $0xf9 // xorq %r15, %r9 LONG $0xd06f0f66 // movdqa %xmm0, %xmm2 LONG $0xd3740f66 // pcmpeqb %xmm3, %xmm2 - LONG $0xd70f4466; BYTE $0xd2 // pmovmskb %xmm2, %r10d + LONG $0xd70f4466; BYTE $0xfa // pmovmskb %xmm2, %r15d LONG $0xd56f0f66 // movdqa %xmm5, %xmm2 LONG $0xd3740f66 // pcmpeqb %xmm3, %xmm2 - LONG $0xcad70f66 // pmovmskb %xmm2, %ecx + LONG $0xd70f4466; BYTE $0xe2 // pmovmskb %xmm2, %r12d LONG $0xd76f0f66 // movdqa %xmm7, %xmm2 LONG $0xd3740f66 // pcmpeqb %xmm3, %xmm2 - LONG $0xf2d70f66 // pmovmskb %xmm2, %esi + LONG $0xdad70f66 // pmovmskb %xmm2, %ebx LONG $0xd66f0f66 // movdqa %xmm6, %xmm2 LONG $0xd3740f66 // pcmpeqb %xmm3, %xmm2 - LONG $0xfad70f66 // pmovmskb %xmm2, %edi - LONG $0x30e7c148 // shlq $48, %rdi - LONG $0x20e6c148 // shlq $32, %rsi - WORD $0x0948; BYTE $0xfe // orq %rdi, %rsi - LONG $0x10e1c148 // shlq $16, %rcx - WORD $0x0948; BYTE $0xf1 // orq %rsi, %rcx - WORD $0x0949; BYTE $0xca // orq %rcx, %r10 - WORD $0x894d; BYTE $0xc4 // movq %r8, %r12 - WORD $0xf749; BYTE $0xd4 // notq %r12 - WORD $0x214d; BYTE $0xe2 // andq %r12, %r10 + LONG $0xcad70f66 // pmovmskb %xmm2, %ecx + LONG $0x30e1c148 // shlq $48, %rcx + LONG $0x20e3c148 // shlq $32, %rbx + LONG $0x10e4c149 // shlq $16, %r12 + WORD $0x094d; BYTE $0xe7 // orq %r12, %r15 + WORD $0x0949; BYTE $0xdf // orq %rbx, %r15 + WORD $0x0949; BYTE $0xcf // orq %rcx, %r15 + WORD $0x894c; BYTE $0xc9 // movq %r9, %rcx + WORD $0xf748; BYTE $0xd1 // notq %rcx + WORD $0x2149; BYTE $0xcf // andq %rcx, %r15 LONG $0xc4740f66 // pcmpeqb %xmm4, %xmm0 - LONG $0xf8d70f66 // pmovmskb %xmm0, %edi + LONG $0xd70f4466; BYTE $0xe0 // pmovmskb %xmm0, %r12d LONG $0xec740f66 // pcmpeqb %xmm4, %xmm5 - LONG $0xcdd70f66 // pmovmskb %xmm5, %ecx + LONG $0xddd70f66 // pmovmskb %xmm5, %ebx LONG $0xfc740f66 // pcmpeqb %xmm4, %xmm7 - LONG $0xdfd70f66 // pmovmskb %xmm7, %ebx + LONG $0xd70f4466; BYTE $0xd7 // pmovmskb %xmm7, %r10d LONG $0xf4740f66 // pcmpeqb %xmm4, %xmm6 - LONG $0xf6d70f66 // pmovmskb %xmm6, %esi - LONG $0x30e6c148 // shlq $48, %rsi - LONG $0x20e3c148 // shlq $32, %rbx - WORD $0x0948; BYTE $0xf3 // orq %rsi, %rbx - LONG $0x10e1c148 // shlq $16, %rcx - WORD $0x0948; BYTE $0xd9 // orq %rbx, %rcx - WORD $0x0948; BYTE $0xcf // orq %rcx, %rdi - QUAD $0x0f0f0f0f0f0fbb48; WORD $0x0f0f // movabsq $1085102592571150095, %rbx - WORD $0x214c; BYTE $0xe7 // andq %r12, %rdi - LONG $0x0066840f; WORD $0x0000 // je LBB32_56, $102(%rip) - QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90 + LONG $0xd70f4466; BYTE $0xee // pmovmskb %xmm6, %r13d + LONG $0x30e5c149 // shlq $48, %r13 + LONG $0x20e2c149 // shlq $32, %r10 + LONG $0x10e3c148 // shlq $16, %rbx + WORD $0x0949; BYTE $0xdc // orq %rbx, %r12 + WORD $0x094d; BYTE $0xd4 // orq %r10, %r12 + WORD $0x094d; BYTE $0xec // orq %r13, %r12 + QUAD $0x555555555555bd49; WORD $0x5555 // movabsq $6148914691236517205, %r13 + QUAD $0x333333333333ba49; WORD $0x3333 // movabsq $3689348814741910323, %r10 + WORD $0x2149; BYTE $0xcc // andq %rcx, %r12 + LONG $0xfdd4840f; WORD $0xffff // je LBB27_84, $-556(%rip) + QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90 -LBB32_62: - LONG $0xff678d4c // leaq $-1(%rdi), %r12 - WORD $0x894c; BYTE $0xe1 // movq %r12, %rcx - WORD $0x214c; BYTE $0xd1 // andq %r10, %rcx - WORD $0x8948; BYTE $0xce // movq %rcx, %rsi - WORD $0xd148; BYTE $0xee // shrq %rsi - WORD $0x214c; BYTE $0xde // andq %r11, %rsi - WORD $0x2948; BYTE $0xf1 // subq %rsi, %rcx - WORD $0x8948; BYTE $0xce // movq %rcx, %rsi - WORD $0x214c; BYTE $0xfe // andq %r15, %rsi - LONG $0x02e9c148 // shrq $2, %rcx - WORD $0x214c; BYTE $0xf9 // andq %r15, %rcx - WORD $0x0148; BYTE $0xf1 // addq %rsi, %rcx - WORD $0x8948; BYTE $0xce // movq %rcx, %rsi - LONG $0x04eec148 // shrq $4, %rsi - WORD $0x0148; BYTE $0xce // addq %rcx, %rsi - WORD $0x2148; BYTE $0xde // andq %rbx, %rsi - QUAD $0x010101010101b948; WORD $0x0101 // movabsq $72340172838076673, %rcx - LONG $0xf1af0f48 // imulq %rcx, %rsi - LONG $0x38eec148 // shrq $56, %rsi - WORD $0x014c; BYTE $0xee // addq %r13, %rsi - WORD $0x394c; BYTE $0xce // cmpq %r9, %rsi - LONG $0x01ad860f; WORD $0x0000 // jbe LBB32_80, $429(%rip) - WORD $0xff49; BYTE $0xc1 // incq %r9 - WORD $0x214c; BYTE $0xe7 // andq %r12, %rdi - LONG $0xffa3850f; WORD $0xffff // jne LBB32_62, $-93(%rip) - -LBB32_56: - LONG $0x3ff8c149 // sarq $63, %r8 - WORD $0x894c; BYTE $0xd1 // movq %r10, %rcx +LBB27_90: + LONG $0x24548d49; BYTE $0xff // leaq $-1(%r12), %rdx + WORD $0x8948; BYTE $0xd3 // movq %rdx, %rbx + WORD $0x214c; BYTE $0xfb // andq %r15, %rbx + WORD $0x8948; BYTE $0xd9 // movq %rbx, %rcx WORD $0xd148; BYTE $0xe9 // shrq %rcx - WORD $0x214c; BYTE $0xd9 // andq %r11, %rcx - WORD $0x2949; BYTE $0xca // subq %rcx, %r10 - WORD $0x894c; BYTE $0xd1 // movq %r10, %rcx - WORD $0x214c; BYTE $0xf9 // andq %r15, %rcx - LONG $0x02eac149 // shrq $2, %r10 - WORD $0x214d; BYTE $0xfa // andq %r15, %r10 - WORD $0x0149; BYTE $0xca // addq %rcx, %r10 - WORD $0x894c; BYTE $0xd1 // movq %r10, %rcx + WORD $0x214c; BYTE $0xe9 // andq %r13, %rcx + WORD $0x2948; BYTE $0xcb // subq %rcx, %rbx + WORD $0x8948; BYTE $0xd9 // movq %rbx, %rcx + WORD $0x214c; BYTE $0xd1 // andq %r10, %rcx + LONG $0x02ebc148 // shrq $2, %rbx + WORD $0x214c; BYTE $0xd3 // andq %r10, %rbx + WORD $0x0148; BYTE $0xcb // addq %rcx, %rbx + WORD $0x8948; BYTE $0xd9 // movq %rbx, %rcx LONG $0x04e9c148 // shrq $4, %rcx - WORD $0x014c; BYTE $0xd1 // addq %r10, %rcx + WORD $0x0148; BYTE $0xd9 // addq %rbx, %rcx + QUAD $0x0f0f0f0f0f0fbb48; WORD $0x0f0f // movabsq $1085102592571150095, %rbx WORD $0x2148; BYTE $0xd9 // andq %rbx, %rcx - QUAD $0x010101010101be48; WORD $0x0101 // movabsq $72340172838076673, %rsi - LONG $0xceaf0f48 // imulq %rsi, %rcx + QUAD $0x010101010101bb48; WORD $0x0101 // movabsq $72340172838076673, %rbx + LONG $0xcbaf0f48 // imulq %rbx, %rcx LONG $0x38e9c148 // shrq $56, %rcx - WORD $0x0149; BYTE $0xcd // addq %rcx, %r13 - LONG $0x40c28348 // addq $64, %rdx - LONG $0xd04d8b48 // movq $-48(%rbp), %rcx - LONG $0xc0c18348 // addq $-64, %rcx - WORD $0x894d; BYTE $0xc4 // movq %r8, %r12 - LONG $0xc0558b4c // movq $-64(%rbp), %r10 - LONG $0x40f98348 // cmpq $64, %rcx - LONG $0xd04d8948 // movq %rcx, $-48(%rbp) - LONG $0xfd8b8d0f; WORD $0xffff // jge LBB32_58, $-629(%rip) + LONG $0xc04d0348 // addq $-64(%rbp), %rcx + WORD $0x394c; BYTE $0xd9 // cmpq %r11, %rcx + LONG $0x0153860f; WORD $0x0000 // jbe LBB27_108, $339(%rip) + WORD $0xff49; BYTE $0xc3 // incq %r11 + WORD $0x2149; BYTE $0xd4 // andq %rdx, %r12 + LONG $0xff97850f; WORD $0xffff // jne LBB27_90, $-105(%rip) + LONG $0xfffd5ae9; BYTE $0xff // jmp LBB27_84, $-678(%rip) -LBB32_64: +LBB27_92: WORD $0x8548; BYTE $0xc9 // testq %rcx, %rcx - LONG $0x01b08e0f; WORD $0x0000 // jle LBB32_85, $432(%rip) - WORD $0x894c; BYTE $0xd7 // movq %r10, %rdi + LONG $0x01f68e0f; WORD $0x0000 // jle LBB27_117, $502(%rip) + WORD $0x894c; BYTE $0xd3 // movq %r10, %rbx + LONG $0x45110f44; BYTE $0xb0 // movups %xmm8, $-80(%rbp) LONG $0x45110f44; BYTE $0xa0 // movups %xmm8, $-96(%rbp) LONG $0x45110f44; BYTE $0x90 // movups %xmm8, $-112(%rbp) LONG $0x45110f44; BYTE $0x80 // movups %xmm8, $-128(%rbp) - QUAD $0xffffff7085110f44 // movups %xmm8, $-144(%rbp) - WORD $0xd189 // movl %edx, %ecx + WORD $0x8944; BYTE $0xc1 // movl %r8d, %ecx LONG $0x0fffe181; WORD $0x0000 // andl $4095, %ecx LONG $0x0fc1f981; WORD $0x0000 // cmpl $4033, %ecx - LONG $0x0036820f; WORD $0x0000 // jb LBB32_68, $54(%rip) + LONG $0x0031820f; WORD $0x0000 // jb LBB27_96, $49(%rip) LONG $0xd07d8348; BYTE $0x20 // cmpq $32, $-48(%rbp) - LONG $0x0033820f; WORD $0x0000 // jb LBB32_69, $51(%rip) - LONG $0x026f0ff3 // movdqu (%rdx), %xmm0 - LONG $0x526f0ff3; BYTE $0x10 // movdqu $16(%rdx), %xmm2 - QUAD $0xffffff70857f0ff3 // movdqu %xmm0, $-144(%rbp) - LONG $0x557f0ff3; BYTE $0x80 // movdqu %xmm2, $-128(%rbp) - LONG $0x20c28348 // addq $32, %rdx + LONG $0x0038820f; WORD $0x0000 // jb LBB27_97, $56(%rip) + LONG $0x00100f41 // movups (%r8), %xmm0 + LONG $0x8045110f // movups %xmm0, $-128(%rbp) + LONG $0x40100f41; BYTE $0x10 // movups $16(%r8), %xmm0 + LONG $0x9045110f // movups %xmm0, $-112(%rbp) + LONG $0x20c08349 // addq $32, %r8 LONG $0xd04d8b48 // movq $-48(%rbp), %rcx - LONG $0xe0518d4c // leaq $-32(%rcx), %r10 - LONG $0x90458d4c // leaq $-112(%rbp), %r8 - LONG $0x000013e9; BYTE $0x00 // jmp LBB32_70, $19(%rip) + LONG $0xe0518d48 // leaq $-32(%rcx), %rdx + LONG $0xa04d8d4c // leaq $-96(%rbp), %r9 + LONG $0x00001ae9; BYTE $0x00 // jmp LBB27_98, $26(%rip) -LBB32_68: - WORD $0x8949; BYTE $0xfa // movq %rdi, %r10 - LONG $0xfffd16e9; BYTE $0xff // jmp LBB32_58, $-746(%rip) +LBB27_96: + QUAD $0x555555555555bd49; WORD $0x5555 // movabsq $6148914691236517205, %r13 + WORD $0x8949; BYTE $0xda // movq %rbx, %r10 + LONG $0xfffd50e9; BYTE $0xff // jmp LBB27_86, $-688(%rip) -LBB32_69: - LONG $0x70858d4c; WORD $0xffff; BYTE $0xff // leaq $-144(%rbp), %r8 - LONG $0xd0558b4c // movq $-48(%rbp), %r10 +LBB27_97: + LONG $0x804d8d4c // leaq $-128(%rbp), %r9 + LONG $0xd0558b48 // movq $-48(%rbp), %rdx -LBB32_70: - LONG $0x10fa8349 // cmpq $16, %r10 - LONG $0x0049820f; WORD $0x0000 // jb LBB32_71, $73(%rip) - LONG $0x026f0ff3 // movdqu (%rdx), %xmm0 - LONG $0x7f0f41f3; BYTE $0x00 // movdqu %xmm0, (%r8) - LONG $0x10c28348 // addq $16, %rdx +LBB27_98: + LONG $0x10fa8348 // cmpq $16, %rdx + LONG $0x0049820f; WORD $0x0000 // jb LBB27_99, $73(%rip) + LONG $0x00100f41 // movups (%r8), %xmm0 + LONG $0x01110f41 // movups %xmm0, (%r9) LONG $0x10c08349 // addq $16, %r8 - LONG $0xf0c28349 // addq $-16, %r10 - LONG $0x08fa8349 // cmpq $8, %r10 - LONG $0x0034830f; WORD $0x0000 // jae LBB32_78, $52(%rip) + LONG $0x10c18349 // addq $16, %r9 + LONG $0xf0c28348 // addq $-16, %rdx + LONG $0x08fa8348 // cmpq $8, %rdx + LONG $0x0035830f; WORD $0x0000 // jae LBB27_106, $53(%rip) -LBB32_72: - LONG $0x04fa8349 // cmpq $4, %r10 - LONG $0x0046820f; WORD $0x0000 // jb LBB32_73, $70(%rip) +LBB27_100: + LONG $0x04fa8348 // cmpq $4, %rdx + LONG $0x00478c0f; WORD $0x0000 // jl LBB27_101, $71(%rip) -LBB32_79: - WORD $0x0a8b // movl (%rdx), %ecx - WORD $0x8941; BYTE $0x08 // movl %ecx, (%r8) - LONG $0x04c28348 // addq $4, %rdx +LBB27_107: + WORD $0x8b41; BYTE $0x08 // movl (%r8), %ecx + WORD $0x8941; BYTE $0x09 // movl %ecx, (%r9) LONG $0x04c08349 // addq $4, %r8 - LONG $0xfcc28349 // addq $-4, %r10 - LONG $0x02fa8349 // cmpq $2, %r10 - LONG $0x0035830f; WORD $0x0000 // jae LBB32_74, $53(%rip) - LONG $0x000043e9; BYTE $0x00 // jmp LBB32_75, $67(%rip) + LONG $0x04c18349 // addq $4, %r9 + LONG $0xfcc28348 // addq $-4, %rdx + LONG $0x02fa8348 // cmpq $2, %rdx + LONG $0x0035830f; WORD $0x0000 // jae LBB27_102, $53(%rip) + LONG $0x000044e9; BYTE $0x00 // jmp LBB27_103, $68(%rip) -LBB32_71: - LONG $0x08fa8349 // cmpq $8, %r10 - LONG $0xffcc820f; WORD $0xffff // jb LBB32_72, $-52(%rip) +LBB27_99: + LONG $0x08fa8348 // cmpq $8, %rdx + LONG $0xffcb820f; WORD $0xffff // jb LBB27_100, $-53(%rip) -LBB32_78: - WORD $0x8b48; BYTE $0x0a // movq (%rdx), %rcx - WORD $0x8949; BYTE $0x08 // movq %rcx, (%r8) - LONG $0x08c28348 // addq $8, %rdx +LBB27_106: + WORD $0x8b49; BYTE $0x08 // movq (%r8), %rcx + WORD $0x8949; BYTE $0x09 // movq %rcx, (%r9) LONG $0x08c08349 // addq $8, %r8 - LONG $0xf8c28349 // addq $-8, %r10 - LONG $0x04fa8349 // cmpq $4, %r10 - LONG $0xffba830f; WORD $0xffff // jae LBB32_79, $-70(%rip) - -LBB32_73: - LONG $0x02fa8349 // cmpq $2, %r10 - LONG $0x0013820f; WORD $0x0000 // jb LBB32_75, $19(%rip) + LONG $0x08c18349 // addq $8, %r9 + LONG $0xf8c28348 // addq $-8, %rdx + LONG $0x04fa8348 // cmpq $4, %rdx + LONG $0xffb98d0f; WORD $0xffff // jge LBB27_107, $-71(%rip) -LBB32_74: - WORD $0xb70f; BYTE $0x0a // movzwl (%rdx), %ecx - LONG $0x08894166 // movw %cx, (%r8) - LONG $0x02c28348 // addq $2, %rdx - LONG $0x02c08349 // addq $2, %r8 - LONG $0xfec28349 // addq $-2, %r10 +LBB27_101: + LONG $0x02fa8348 // cmpq $2, %rdx + LONG $0x0014820f; WORD $0x0000 // jb LBB27_103, $20(%rip) -LBB32_75: - WORD $0x8948; BYTE $0xd6 // movq %rdx, %rsi - LONG $0x70958d48; WORD $0xffff; BYTE $0xff // leaq $-144(%rbp), %rdx - WORD $0x854d; BYTE $0xd2 // testq %r10, %r10 - WORD $0x8949; BYTE $0xfa // movq %rdi, %r10 - LONG $0xfc5f840f; WORD $0xffff // je LBB32_58, $-929(%rip) - WORD $0xb60f; BYTE $0x0e // movzbl (%rsi), %ecx - WORD $0x8841; BYTE $0x08 // movb %cl, (%r8) - LONG $0x70958d48; WORD $0xffff; BYTE $0xff // leaq $-144(%rbp), %rdx - LONG $0xfffc4de9; BYTE $0xff // jmp LBB32_58, $-947(%rip) +LBB27_102: + LONG $0x08b70f41 // movzwl (%r8), %ecx + LONG $0x09894166 // movw %cx, (%r9) + LONG $0x02c08349 // addq $2, %r8 + LONG $0x02c18349 // addq $2, %r9 + LONG $0xfec28348 // addq $-2, %rdx -LBB32_80: - LONG $0x08468b49 // movq $8(%r14), %rax - LONG $0xcfbc0f48 // bsfq %rdi, %rcx +LBB27_103: + WORD $0x894c; BYTE $0xc1 // movq %r8, %rcx + LONG $0x80458d4c // leaq $-128(%rbp), %r8 + WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx + QUAD $0x555555555555bd49; WORD $0x5555 // movabsq $6148914691236517205, %r13 + WORD $0x8949; BYTE $0xda // movq %rbx, %r10 + LONG $0xfc94840f; WORD $0xffff // je LBB27_86, $-876(%rip) + WORD $0x098a // movb (%rcx), %cl + WORD $0x8841; BYTE $0x09 // movb %cl, (%r9) + LONG $0x80458d4c // leaq $-128(%rbp), %r8 + LONG $0xfffc86e9; BYTE $0xff // jmp LBB27_86, $-890(%rip) + +LBB27_108: + LONG $0x08478b48 // movq $8(%rdi), %rax + LONG $0xccbc0f49 // bsfq %r12, %rcx LONG $0xd04d2b48 // subq $-48(%rbp), %rcx - WORD $0x0148; BYTE $0xc8 // addq %rcx, %rax - WORD $0xff48; BYTE $0xc0 // incq %rax - LONG $0xc8558b48 // movq $-56(%rbp), %rdx - WORD $0x8948; BYTE $0x02 // movq %rax, (%rdx) - LONG $0x084e8b49 // movq $8(%r14), %rcx + LONG $0x01448d48; BYTE $0x01 // leaq $1(%rcx,%rax), %rax + WORD $0x8948; BYTE $0x06 // movq %rax, (%rsi) + LONG $0x084f8b48 // movq $8(%rdi), %rcx WORD $0x3948; BYTE $0xc8 // cmpq %rcx, %rax - LONG $0xc8420f48 // cmovbq %rax, %rcx - WORD $0x8948; BYTE $0x0a // movq %rcx, (%rdx) + LONG $0xc1470f48 // cmovaq %rcx, %rax + WORD $0x8948; BYTE $0x06 // movq %rax, (%rsi) LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax - LONG $0xb84d8b48 // movq $-72(%rbp), %rcx - LONG $0xc8470f48 // cmovaq %rax, %rcx - WORD $0x8948; BYTE $0xc8 // movq %rcx, %rax - LONG $0xfff645e9; BYTE $0xff // jmp LBB32_17, $-2491(%rip) + LONG $0xf0470f4c // cmovaq %rax, %r14 + LONG $0xfff607e9; BYTE $0xff // jmp LBB27_43, $-2553(%rip) -LBB32_82: - WORD $0x2948; BYTE $0xc2 // subq %rax, %rdx - WORD $0x0148; BYTE $0xca // addq %rcx, %rdx - -LBB32_83: - LONG $0x00558949 // movq %rdx, (%r13) - LONG $0xfff633e9; BYTE $0xff // jmp LBB32_16, $-2509(%rip) - -LBB32_26: - WORD $0x854d; BYTE $0xdb // testq %r11, %r11 - LONG $0x0035850f; WORD $0x0000 // jne LBB32_86, $53(%rip) - WORD $0x014d; BYTE $0xe2 // addq %r12, %r10 - WORD $0x014d; BYTE $0xf1 // addq %r14, %r9 - -LBB32_28: - WORD $0x854d; BYTE $0xc9 // testq %r9, %r9 - LONG $0x0068850f; WORD $0x0000 // jne LBB32_90, $104(%rip) - LONG $0xfff619e9; BYTE $0xff // jmp LBB32_17, $-2535(%rip) +LBB27_53: + WORD $0x854d; BYTE $0xe4 // testq %r12, %r12 + LONG $0x008e850f; WORD $0x0000 // jne LBB27_118, $142(%rip) + LONG $0x1f5c8d4b; BYTE $0x01 // leaq $1(%r15,%r11), %rbx + WORD $0xf749; BYTE $0xd7 // notq %r15 + WORD $0x014d; BYTE $0xcf // addq %r9, %r15 -LBB32_84: - WORD $0x0148; BYTE $0xc2 // addq %rax, %rdx - WORD $0x8548; BYTE $0xf6 // testq %rsi, %rsi - LONG $0xf5c0850f; WORD $0xffff // jne LBB32_7, $-2624(%rip) - LONG $0xfff5efe9; BYTE $0xff // jmp LBB32_13, $-2577(%rip) - -LBB32_85: - LONG $0x084e8b49 // movq $8(%r14), %rcx - LONG $0xc8558b48 // movq $-56(%rbp), %rdx - WORD $0x8948; BYTE $0x0a // movq %rcx, (%rdx) - LONG $0xfff5f8e9; BYTE $0xff // jmp LBB32_17, $-2568(%rip) - -LBB32_86: - WORD $0x394d; BYTE $0xe1 // cmpq %r12, %r9 - LONG $0xf5ef840f; WORD $0xffff // je LBB32_17, $-2577(%rip) - WORD $0x014d; BYTE $0xe2 // addq %r12, %r10 - WORD $0xff49; BYTE $0xc2 // incq %r10 - WORD $0xf749; BYTE $0xd4 // notq %r12 - WORD $0x014d; BYTE $0xe1 // addq %r12, %r9 - WORD $0x854d; BYTE $0xc9 // testq %r9, %r9 - LONG $0x0024850f; WORD $0x0000 // jne LBB32_90, $36(%rip) - LONG $0xfff5d5e9; BYTE $0xff // jmp LBB32_17, $-2603(%rip) +LBB27_55: + WORD $0x854d; BYTE $0xff // testq %r15, %r15 + LONG $0x00248f0f; WORD $0x0000 // jg LBB27_112, $36(%rip) + LONG $0xfff5e8e9; BYTE $0xff // jmp LBB27_44, $-2584(%rip) -LBB32_88: +LBB27_110: LONG $0xfec1c748; WORD $0xffff; BYTE $0xff // movq $-2, %rcx LONG $0x000002b8; BYTE $0x00 // movl $2, %eax - WORD $0x0149; BYTE $0xc2 // addq %rax, %r10 + WORD $0x0148; BYTE $0xc3 // addq %rax, %rbx LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax - WORD $0x0149; BYTE $0xc9 // addq %rcx, %r9 - LONG $0xf5b6840f; WORD $0xffff // je LBB32_17, $-2634(%rip) - -LBB32_90: - LONG $0x02b60f41 // movzbl (%r10), %eax - WORD $0xf883; BYTE $0x5c // cmpl $92, %eax - LONG $0xffd4840f; WORD $0xffff // je LBB32_88, $-44(%rip) - WORD $0xf883; BYTE $0x22 // cmpl $34, %eax - LONG $0x0024840f; WORD $0x0000 // je LBB32_93, $36(%rip) + WORD $0x0149; BYTE $0xcf // addq %rcx, %r15 + LONG $0xf5c98e0f; WORD $0xffff // jle LBB27_44, $-2615(%rip) + +LBB27_112: + WORD $0xb60f; BYTE $0x03 // movzbl (%rbx), %eax + WORD $0x5c3c // cmpb $92, %al + LONG $0xffd6840f; WORD $0xffff // je LBB27_110, $-42(%rip) + WORD $0x223c // cmpb $34, %al + LONG $0x0024840f; WORD $0x0000 // je LBB27_115, $36(%rip) LONG $0xffc1c748; WORD $0xffff; BYTE $0xff // movq $-1, %rcx LONG $0x000001b8; BYTE $0x00 // movl $1, %eax - WORD $0x0149; BYTE $0xc2 // addq %rax, %r10 + WORD $0x0148; BYTE $0xc3 // addq %rax, %rbx LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax - WORD $0x0149; BYTE $0xc9 // addq %rcx, %r9 - LONG $0xffcb850f; WORD $0xffff // jne LBB32_90, $-53(%rip) - LONG $0xfff57ce9; BYTE $0xff // jmp LBB32_17, $-2692(%rip) + WORD $0x0149; BYTE $0xcf // addq %rcx, %r15 + LONG $0xffce8f0f; WORD $0xffff // jg LBB27_112, $-50(%rip) + LONG $0xfff592e9; BYTE $0xff // jmp LBB27_44, $-2670(%rip) + +LBB27_115: + WORD $0x294c; BYTE $0xc3 // subq %r8, %rbx + WORD $0xff48; BYTE $0xc3 // incq %rbx + LONG $0xfff581e9; BYTE $0xff // jmp LBB27_42, $-2687(%rip) + +LBB27_116: + WORD $0x014c; BYTE $0xc3 // addq %r8, %rbx + LONG $0xffff89e9; BYTE $0xff // jmp LBB27_55, $-119(%rip) + +LBB27_117: + LONG $0x084f8b48 // movq $8(%rdi), %rcx + WORD $0x8948; BYTE $0x0e // movq %rcx, (%rsi) + LONG $0xfff573e9; BYTE $0xff // jmp LBB27_44, $-2701(%rip) + +LBB27_118: + LONG $0xff498d49 // leaq $-1(%r9), %rcx + WORD $0x394c; BYTE $0xf9 // cmpq %r15, %rcx + LONG $0xf566840f; WORD $0xffff // je LBB27_44, $-2714(%rip) + LONG $0x1f5c8d4b; BYTE $0x02 // leaq $2(%r15,%r11), %rbx + WORD $0x294d; BYTE $0xf9 // subq %r15, %r9 + LONG $0xfec18349 // addq $-2, %r9 + WORD $0x894d; BYTE $0xcf // movq %r9, %r15 + LONG $0xffff5ce9; BYTE $0xff // jmp LBB27_55, $-164(%rip) + WORD $0x9090 // .p2align 2, 0x90 + + // .set L27_0_set_44, LBB27_44-LJTI27_0 + // .set L27_0_set_46, LBB27_46-LJTI27_0 + // .set L27_0_set_47, LBB27_47-LJTI27_0 + // .set L27_0_set_29, LBB27_29-LJTI27_0 + // .set L27_0_set_56, LBB27_56-LJTI27_0 + // .set L27_0_set_81, LBB27_81-LJTI27_0 + // .set L27_0_set_45, LBB27_45-LJTI27_0 + // .set L27_0_set_83, LBB27_83-LJTI27_0 +LJTI27_0: + LONG $0xfffff550 // .long L27_0_set_44 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff581 // .long L27_0_set_47 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff48f // .long L27_0_set_29 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff48f // .long L27_0_set_29 + LONG $0xfffff48f // .long L27_0_set_29 + LONG $0xfffff48f // .long L27_0_set_29 + LONG $0xfffff48f // .long L27_0_set_29 + LONG $0xfffff48f // .long L27_0_set_29 + LONG $0xfffff48f // .long L27_0_set_29 + LONG $0xfffff48f // .long L27_0_set_29 + LONG $0xfffff48f // .long L27_0_set_29 + LONG $0xfffff48f // .long L27_0_set_29 + LONG $0xfffff48f // .long L27_0_set_29 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff68e // .long L27_0_set_56 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffffac4 // .long L27_0_set_81 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff55f // .long L27_0_set_45 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff55f // .long L27_0_set_45 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffff572 // .long L27_0_set_46 + LONG $0xfffffada // .long L27_0_set_83 + LONG $0x00000000 // .p2align 4, 0x00 -LBB32_93: - LONG $0xd0552b4c // subq $-48(%rbp), %r10 - WORD $0xff49; BYTE $0xc2 // incq %r10 - LONG $0x0055894d // movq %r10, (%r13) - LONG $0xfff569e9; BYTE $0xff // jmp LBB32_16, $-2711(%rip) - WORD $0x9090; BYTE $0x90 // .p2align 2, 0x90 - - // .set L32_0_set_17, LBB32_17-LJTI32_0 - // .set L32_0_set_19, LBB32_19-LJTI32_0 - // .set L32_0_set_20, LBB32_20-LJTI32_0 - // .set L32_0_set_2, LBB32_2-LJTI32_0 - // .set L32_0_set_29, LBB32_29-LJTI32_0 - // .set L32_0_set_54, LBB32_54-LJTI32_0 - // .set L32_0_set_18, LBB32_18-LJTI32_0 - // .set L32_0_set_55, LBB32_55-LJTI32_0 -LJTI32_0: - LONG $0xfffff569 // .long L32_0_set_17 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff59b // .long L32_0_set_20 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff489 // .long L32_0_set_2 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff489 // .long L32_0_set_2 - LONG $0xfffff489 // .long L32_0_set_2 - LONG $0xfffff489 // .long L32_0_set_2 - LONG $0xfffff489 // .long L32_0_set_2 - LONG $0xfffff489 // .long L32_0_set_2 - LONG $0xfffff489 // .long L32_0_set_2 - LONG $0xfffff489 // .long L32_0_set_2 - LONG $0xfffff489 // .long L32_0_set_2 - LONG $0xfffff489 // .long L32_0_set_2 - LONG $0xfffff489 // .long L32_0_set_2 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff69a // .long L32_0_set_29 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffffab6 // .long L32_0_set_54 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff578 // .long L32_0_set_18 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff578 // .long L32_0_set_18 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffff58b // .long L32_0_set_19 - LONG $0xfffffac9 // .long L32_0_set_55 - QUAD $0x9090909090909090 // .p2align 4, 0x90 +LCPI28_0: + LONG $0x00000001 // .long 1 + LONG $0x00000000 // .long 0 + LONG $0x00000000 // .long 0 + LONG $0x00000000 // .long 0 + // .p2align 4, 0x90 _get_by_path: - BYTE $0x55 // pushq %rbp - WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp - WORD $0x5741 // pushq %r15 - WORD $0x5641 // pushq %r14 - WORD $0x5541 // pushq %r13 - WORD $0x5441 // pushq %r12 - BYTE $0x53 // pushq %rbx - LONG $0x38ec8348 // subq $56, %rsp - WORD $0x8949; BYTE $0xf4 // movq %rsi, %r12 - WORD $0x8949; BYTE $0xfe // movq %rdi, %r14 - LONG $0x08428b48 // movq $8(%rdx), %rax - WORD $0x8548; BYTE $0xc0 // testq %rax, %rax - LONG $0x037d840f; WORD $0x0000 // je LBB33_53, $893(%rip) - WORD $0x8b4c; BYTE $0x3a // movq (%rdx), %r15 - LONG $0x04e0c148 // shlq $4, %rax - WORD $0x014c; BYTE $0xf8 // addq %r15, %rax - LONG $0xa0458948 // movq %rax, $-96(%rbp) - -LBB33_2: - WORD $0x8b49; BYTE $0x3e // movq (%r14), %rdi - LONG $0x08768b49 // movq $8(%r14), %rsi - WORD $0x894c; BYTE $0xe2 // movq %r12, %rdx - LONG $0xffd23fe8; BYTE $0xff // callq _advance_ns, $-11713(%rip) - WORD $0x8b49; BYTE $0x0f // movq (%r15), %rcx - LONG $0x1749b60f // movzbl $23(%rcx), %ecx - WORD $0xe180; BYTE $0x1f // andb $31, %cl - WORD $0xf980; BYTE $0x18 // cmpb $24, %cl - LONG $0x02dc850f; WORD $0x0000 // jne LBB33_47, $732(%rip) - WORD $0x7b3c // cmpb $123, %al - LONG $0xc865894c // movq %r12, $-56(%rbp) - LONG $0xd07d894c // movq %r15, $-48(%rbp) - LONG $0x034d850f; WORD $0x0000 // jne LBB33_54, $845(%rip) + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5741 // pushq %r15 + WORD $0x5641 // pushq %r14 + WORD $0x5541 // pushq %r13 + WORD $0x5441 // pushq %r12 + BYTE $0x53 // pushq %rbx + LONG $0x38ec8348 // subq $56, %rsp + WORD $0x8949; BYTE $0xf7 // movq %rsi, %r15 + WORD $0x8949; BYTE $0xfb // movq %rdi, %r11 + LONG $0x08528b4c // movq $8(%rdx), %r10 + WORD $0x854d; BYTE $0xd2 // testq %r10, %r10 + LONG $0x0f0f840f; WORD $0x0000 // je LBB28_241, $3855(%rip) + WORD $0x8b48; BYTE $0x02 // movq (%rdx), %rax + LONG $0x04e2c149 // shlq $4, %r10 + LONG $0xb8458948 // movq %rax, $-72(%rbp) + WORD $0x0149; BYTE $0xc2 // addq %rax, %r10 + WORD $0x8b4d; BYTE $0x0b // movq (%r11), %r9 + WORD $0x8b49; BYTE $0x17 // movq (%r15), %rdx + QUAD $0x000100002600bc49; WORD $0x0000 // movabsq $4294977024, %r12 + LONG $0xc05d894c // movq %r11, $-64(%rbp) + LONG $0xa04d8948 // movq %rcx, $-96(%rbp) + LONG $0xa855894c // movq %r10, $-88(%rbp) + +LBB28_2: + LONG $0x08438b4d // movq $8(%r11), %r8 + WORD $0x8948; BYTE $0xd7 // movq %rdx, %rdi + WORD $0x294c; BYTE $0xc7 // subq %r8, %rdi + LONG $0x0032830f; WORD $0x0000 // jae LBB28_7, $50(%rip) + LONG $0x11048a41 // movb (%r9,%rdx), %al + WORD $0x0d3c // cmpb $13, %al + LONG $0x0026840f; WORD $0x0000 // je LBB28_7, $38(%rip) + WORD $0x203c // cmpb $32, %al + LONG $0x001e840f; WORD $0x0000 // je LBB28_7, $30(%rip) + WORD $0xf704 // addb $-9, %al + WORD $0x013c // cmpb $1, %al + LONG $0x0014860f; WORD $0x0000 // jbe LBB28_7, $20(%rip) + WORD $0x8948; BYTE $0xd6 // movq %rdx, %rsi + LONG $0x0000fee9; BYTE $0x00 // jmp LBB28_28, $254(%rip) QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90 -LBB33_4: - WORD $0x8b49; BYTE $0x3e // movq (%r14), %rdi - LONG $0x08768b49 // movq $8(%r14), %rsi - WORD $0x894c; BYTE $0xe2 // movq %r12, %rdx - LONG $0xffd201e8; BYTE $0xff // callq _advance_ns, $-11775(%rip) - WORD $0x223c // cmpb $34, %al - LONG $0x032a850f; WORD $0x0000 // jne LBB33_54, $810(%rip) - LONG $0x08478b49 // movq $8(%r15), %rax - WORD $0x8b4c; BYTE $0x28 // movq (%rax), %r13 +LBB28_7: + LONG $0x01728d48 // leaq $1(%rdx), %rsi + WORD $0x394c; BYTE $0xc6 // cmpq %r8, %rsi + LONG $0x0023830f; WORD $0x0000 // jae LBB28_11, $35(%rip) + LONG $0x31048a41 // movb (%r9,%rsi), %al + WORD $0x0d3c // cmpb $13, %al + LONG $0x0017840f; WORD $0x0000 // je LBB28_11, $23(%rip) + WORD $0x203c // cmpb $32, %al + LONG $0x000f840f; WORD $0x0000 // je LBB28_11, $15(%rip) + WORD $0xf704 // addb $-9, %al + WORD $0x013c // cmpb $1, %al + LONG $0x00c7870f; WORD $0x0000 // ja LBB28_28, $199(%rip) + LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB28_11: + LONG $0x02728d48 // leaq $2(%rdx), %rsi + WORD $0x394c; BYTE $0xc6 // cmpq %r8, %rsi + LONG $0x0023830f; WORD $0x0000 // jae LBB28_15, $35(%rip) + LONG $0x31048a41 // movb (%r9,%rsi), %al + WORD $0x0d3c // cmpb $13, %al + LONG $0x0017840f; WORD $0x0000 // je LBB28_15, $23(%rip) + WORD $0x203c // cmpb $32, %al + LONG $0x000f840f; WORD $0x0000 // je LBB28_15, $15(%rip) + WORD $0xf704 // addb $-9, %al + WORD $0x013c // cmpb $1, %al + LONG $0x0097870f; WORD $0x0000 // ja LBB28_28, $151(%rip) + LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB28_15: + LONG $0x03728d48 // leaq $3(%rdx), %rsi + WORD $0x394c; BYTE $0xc6 // cmpq %r8, %rsi + LONG $0x0023830f; WORD $0x0000 // jae LBB28_19, $35(%rip) + LONG $0x31048a41 // movb (%r9,%rsi), %al + WORD $0x0d3c // cmpb $13, %al + LONG $0x0017840f; WORD $0x0000 // je LBB28_19, $23(%rip) + WORD $0x203c // cmpb $32, %al + LONG $0x000f840f; WORD $0x0000 // je LBB28_19, $15(%rip) + WORD $0xf704 // addb $-9, %al + WORD $0x013c // cmpb $1, %al + LONG $0x0067870f; WORD $0x0000 // ja LBB28_28, $103(%rip) + LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB28_19: + LONG $0x04428d48 // leaq $4(%rdx), %rax + WORD $0x3949; BYTE $0xc0 // cmpq %rax, %r8 + LONG $0x0083860f; WORD $0x0000 // jbe LBB28_25, $131(%rip) + WORD $0x3949; BYTE $0xc0 // cmpq %rax, %r8 + LONG $0x0094840f; WORD $0x0000 // je LBB28_26, $148(%rip) + LONG $0x01048d4b // leaq (%r9,%r8), %rax + LONG $0x04c78348 // addq $4, %rdi + LONG $0x11748d49; BYTE $0x05 // leaq $5(%r9,%rdx), %rsi + QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB28_22: + LONG $0xff5ebe0f // movsbl $-1(%rsi), %ebx + WORD $0xfb83; BYTE $0x20 // cmpl $32, %ebx + LONG $0x0bbd870f; WORD $0x0000 // ja LBB28_29, $3005(%rip) + LONG $0xdca30f49 // btq %rbx, %r12 + LONG $0x0bb3830f; WORD $0x0000 // jae LBB28_29, $2995(%rip) + WORD $0xff48; BYTE $0xc6 // incq %rsi + WORD $0xff48; BYTE $0xc7 // incq %rdi + LONG $0xffdd850f; WORD $0xffff // jne LBB28_22, $-35(%rip) + WORD $0x294c; BYTE $0xc8 // subq %r9, %rax + WORD $0x8948; BYTE $0xc6 // movq %rax, %rsi + WORD $0x394c; BYTE $0xc6 // cmpq %r8, %rsi + LONG $0x005a830f; WORD $0x0000 // jae LBB28_30, $90(%rip) + +LBB28_28: + LONG $0x01468d48 // leaq $1(%rsi), %rax + WORD $0x8949; BYTE $0x07 // movq %rax, (%r15) + LONG $0x31348a41 // movb (%r9,%rsi), %sil + LONG $0xb8558b48 // movq $-72(%rbp), %rdx + WORD $0x8b48; BYTE $0x12 // movq (%rdx), %rdx + WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx + LONG $0x0063850f; WORD $0x0000 // jne LBB28_31, $99(%rip) + LONG $0x000deae9; BYTE $0x00 // jmp LBB28_248, $3562(%rip) + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 + +LBB28_25: + WORD $0x8949; BYTE $0x07 // movq %rax, (%r15) + WORD $0xf631 // xorl %esi, %esi + LONG $0xb8558b48 // movq $-72(%rbp), %rdx + WORD $0x8b48; BYTE $0x12 // movq (%rdx), %rdx + WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx + LONG $0x003b850f; WORD $0x0000 // jne LBB28_31, $59(%rip) + LONG $0x000dc2e9; BYTE $0x00 // jmp LBB28_248, $3522(%rip) + +LBB28_26: + WORD $0x014c; BYTE $0xc8 // addq %r9, %rax + WORD $0x294c; BYTE $0xc8 // subq %r9, %rax + WORD $0x8948; BYTE $0xc6 // movq %rax, %rsi + WORD $0x394c; BYTE $0xc6 // cmpq %r8, %rsi + LONG $0xffa6820f; WORD $0xffff // jb LBB28_28, $-90(%rip) + +LBB28_30: + WORD $0xf631 // xorl %esi, %esi + WORD $0x8948; BYTE $0xd0 // movq %rdx, %rax + LONG $0xb8558b48 // movq $-72(%rbp), %rdx + WORD $0x8b48; BYTE $0x12 // movq (%rdx), %rdx + WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx + LONG $0x0d9b840f; WORD $0x0000 // je LBB28_248, $3483(%rip) + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB28_31: + WORD $0x528a; BYTE $0x17 // movb $23(%rdx), %dl + WORD $0xe280; BYTE $0x1f // andb $31, %dl + WORD $0xfa80; BYTE $0x02 // cmpb $2, %dl + LONG $0x0021840f; WORD $0x0000 // je LBB28_181, $33(%rip) + WORD $0xfa80; BYTE $0x18 // cmpb $24, %dl + LONG $0x0d74850f; WORD $0x0000 // jne LBB28_248, $3444(%rip) + LONG $0x7bfe8040 // cmpb $123, %sil + LONG $0xd07d894c // movq %r15, $-48(%rbp) + LONG $0x0178840f; WORD $0x0000 // je LBB28_34, $376(%rip) + LONG $0x000d32e9; BYTE $0x00 // jmp LBB28_244, $3378(%rip) + LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB28_181: + LONG $0x5bfe8040 // cmpb $91, %sil + LONG $0x0d23850f; WORD $0x0000 // jne LBB28_244, $3363(%rip) + LONG $0xb8558b48 // movq $-72(%rbp), %rdx + LONG $0x08528b48 // movq $8(%rdx), %rdx + WORD $0x8b4c; BYTE $0x32 // movq (%rdx), %r14 + WORD $0x854d; BYTE $0xf6 // testq %r14, %r14 + LONG $0x0d3e880f; WORD $0x0000 // js LBB28_248, $3390(%rip) + LONG $0x08438b4d // movq $8(%r11), %r8 + WORD $0x8948; BYTE $0xc6 // movq %rax, %rsi + WORD $0x294c; BYTE $0xc6 // subq %r8, %rsi + LONG $0x0032830f; WORD $0x0000 // jae LBB28_188, $50(%rip) + LONG $0x01148a41 // movb (%r9,%rax), %dl + WORD $0xfa80; BYTE $0x0d // cmpb $13, %dl + LONG $0x0025840f; WORD $0x0000 // je LBB28_188, $37(%rip) + WORD $0xfa80; BYTE $0x20 // cmpb $32, %dl + LONG $0x001c840f; WORD $0x0000 // je LBB28_188, $28(%rip) + WORD $0xc280; BYTE $0xf7 // addb $-9, %dl + WORD $0xfa80; BYTE $0x01 // cmpb $1, %dl + LONG $0x0010860f; WORD $0x0000 // jbe LBB28_188, $16(%rip) + WORD $0x8948; BYTE $0xc7 // movq %rax, %rdi + LONG $0x000ad2e9; BYTE $0x00 // jmp LBB28_210, $2770(%rip) + QUAD $0x9090909090909090 // .p2align 4, 0x90 + +LBB28_188: + LONG $0x01788d48 // leaq $1(%rax), %rdi + WORD $0x394c; BYTE $0xc7 // cmpq %r8, %rdi + LONG $0x0023830f; WORD $0x0000 // jae LBB28_192, $35(%rip) + LONG $0x39148a41 // movb (%r9,%rdi), %dl + WORD $0xfa80; BYTE $0x0d // cmpb $13, %dl + LONG $0x0016840f; WORD $0x0000 // je LBB28_192, $22(%rip) + WORD $0xfa80; BYTE $0x20 // cmpb $32, %dl + LONG $0x000d840f; WORD $0x0000 // je LBB28_192, $13(%rip) + WORD $0xc280; BYTE $0xf7 // addb $-9, %dl + WORD $0xfa80; BYTE $0x01 // cmpb $1, %dl + LONG $0x0a9b870f; WORD $0x0000 // ja LBB28_210, $2715(%rip) + BYTE $0x90 // .p2align 4, 0x90 + +LBB28_192: + LONG $0x02788d48 // leaq $2(%rax), %rdi + WORD $0x394c; BYTE $0xc7 // cmpq %r8, %rdi + LONG $0x0023830f; WORD $0x0000 // jae LBB28_196, $35(%rip) + LONG $0x39148a41 // movb (%r9,%rdi), %dl + WORD $0xfa80; BYTE $0x0d // cmpb $13, %dl + LONG $0x0016840f; WORD $0x0000 // je LBB28_196, $22(%rip) + WORD $0xfa80; BYTE $0x20 // cmpb $32, %dl + LONG $0x000d840f; WORD $0x0000 // je LBB28_196, $13(%rip) + WORD $0xc280; BYTE $0xf7 // addb $-9, %dl + WORD $0xfa80; BYTE $0x01 // cmpb $1, %dl + LONG $0x0a6b870f; WORD $0x0000 // ja LBB28_210, $2667(%rip) + BYTE $0x90 // .p2align 4, 0x90 + +LBB28_196: + LONG $0x03788d48 // leaq $3(%rax), %rdi + WORD $0x394c; BYTE $0xc7 // cmpq %r8, %rdi + LONG $0x0023830f; WORD $0x0000 // jae LBB28_200, $35(%rip) + LONG $0x39148a41 // movb (%r9,%rdi), %dl + WORD $0xfa80; BYTE $0x0d // cmpb $13, %dl + LONG $0x0016840f; WORD $0x0000 // je LBB28_200, $22(%rip) + WORD $0xfa80; BYTE $0x20 // cmpb $32, %dl + LONG $0x000d840f; WORD $0x0000 // je LBB28_200, $13(%rip) + WORD $0xc280; BYTE $0xf7 // addb $-9, %dl + WORD $0xfa80; BYTE $0x01 // cmpb $1, %dl + LONG $0x0a3b870f; WORD $0x0000 // ja LBB28_210, $2619(%rip) + BYTE $0x90 // .p2align 4, 0x90 + +LBB28_200: + LONG $0x04508d48 // leaq $4(%rax), %rdx + WORD $0x3949; BYTE $0xd0 // cmpq %rdx, %r8 + LONG $0x09e2860f; WORD $0x0000 // jbe LBB28_206, $2530(%rip) + WORD $0x3949; BYTE $0xd0 // cmpq %rdx, %r8 + LONG $0x09fb840f; WORD $0x0000 // je LBB28_207, $2555(%rip) + LONG $0x01148d4b // leaq (%r9,%r8), %rdx + LONG $0x04c68348 // addq $4, %rsi + LONG $0x017c8d49; BYTE $0x05 // leaq $5(%r9,%rax), %rdi + QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB28_203: + LONG $0xff4fbe0f // movsbl $-1(%rdi), %ecx + WORD $0xf983; BYTE $0x20 // cmpl $32, %ecx + LONG $0x09eb870f; WORD $0x0000 // ja LBB28_209, $2539(%rip) + LONG $0xcca30f49 // btq %rcx, %r12 + LONG $0x09e1830f; WORD $0x0000 // jae LBB28_209, $2529(%rip) + WORD $0xff48; BYTE $0xc7 // incq %rdi + WORD $0xff48; BYTE $0xc6 // incq %rsi + LONG $0xffdd850f; WORD $0xffff // jne LBB28_203, $-35(%rip) + LONG $0x0009bce9; BYTE $0x00 // jmp LBB28_208, $2492(%rip) + +LBB28_177: + WORD $0x894c; BYTE $0xca // movq %r9, %rdx + WORD $0xf748; BYTE $0xd2 // notq %rdx + WORD $0x0148; BYTE $0xd7 // addq %rdx, %rdi + WORD $0x3948; BYTE $0xcf // cmpq %rcx, %rdi + LONG $0x0bd3830f; WORD $0x0000 // jae LBB28_244, $3027(%rip) + +LBB28_178: + LONG $0x01478d48 // leaq $1(%rdi), %rax + WORD $0x8949; BYTE $0x07 // movq %rax, (%r15) + LONG $0x390c8a41 // movb (%r9,%rdi), %cl + WORD $0xf980; BYTE $0x2c // cmpb $44, %cl + LONG $0x0c03850f; WORD $0x0000 // jne LBB28_250, $3075(%rip) + +LBB28_34: + LONG $0x084b8b49 // movq $8(%r11), %rcx + WORD $0x8948; BYTE $0xc6 // movq %rax, %rsi + WORD $0x2948; BYTE $0xce // subq %rcx, %rsi + LONG $0x0032830f; WORD $0x0000 // jae LBB28_39, $50(%rip) + LONG $0x01148a41 // movb (%r9,%rax), %dl + WORD $0xfa80; BYTE $0x0d // cmpb $13, %dl + LONG $0x0025840f; WORD $0x0000 // je LBB28_39, $37(%rip) + WORD $0xfa80; BYTE $0x20 // cmpb $32, %dl + LONG $0x001c840f; WORD $0x0000 // je LBB28_39, $28(%rip) + WORD $0xc280; BYTE $0xf7 // addb $-9, %dl + WORD $0xfa80; BYTE $0x01 // cmpb $1, %dl + LONG $0x0010860f; WORD $0x0000 // jbe LBB28_39, $16(%rip) + WORD $0x8949; BYTE $0xc5 // movq %rax, %r13 + LONG $0x00012ae9; BYTE $0x00 // jmp LBB28_60, $298(%rip) + QUAD $0x9090909090909090 // .p2align 4, 0x90 + +LBB28_39: + LONG $0x01688d4c // leaq $1(%rax), %r13 + WORD $0x3949; BYTE $0xcd // cmpq %rcx, %r13 + LONG $0x0023830f; WORD $0x0000 // jae LBB28_43, $35(%rip) + LONG $0x29148a43 // movb (%r9,%r13), %dl + WORD $0xfa80; BYTE $0x0d // cmpb $13, %dl + LONG $0x0016840f; WORD $0x0000 // je LBB28_43, $22(%rip) + WORD $0xfa80; BYTE $0x20 // cmpb $32, %dl + LONG $0x000d840f; WORD $0x0000 // je LBB28_43, $13(%rip) + WORD $0xc280; BYTE $0xf7 // addb $-9, %dl + WORD $0xfa80; BYTE $0x01 // cmpb $1, %dl + LONG $0x00f3870f; WORD $0x0000 // ja LBB28_60, $243(%rip) + BYTE $0x90 // .p2align 4, 0x90 + +LBB28_43: + LONG $0x02688d4c // leaq $2(%rax), %r13 + WORD $0x3949; BYTE $0xcd // cmpq %rcx, %r13 + LONG $0x0023830f; WORD $0x0000 // jae LBB28_47, $35(%rip) + LONG $0x29148a43 // movb (%r9,%r13), %dl + WORD $0xfa80; BYTE $0x0d // cmpb $13, %dl + LONG $0x0016840f; WORD $0x0000 // je LBB28_47, $22(%rip) + WORD $0xfa80; BYTE $0x20 // cmpb $32, %dl + LONG $0x000d840f; WORD $0x0000 // je LBB28_47, $13(%rip) + WORD $0xc280; BYTE $0xf7 // addb $-9, %dl + WORD $0xfa80; BYTE $0x01 // cmpb $1, %dl + LONG $0x00c3870f; WORD $0x0000 // ja LBB28_60, $195(%rip) + BYTE $0x90 // .p2align 4, 0x90 + +LBB28_47: + LONG $0x03688d4c // leaq $3(%rax), %r13 + WORD $0x3949; BYTE $0xcd // cmpq %rcx, %r13 + LONG $0x0023830f; WORD $0x0000 // jae LBB28_51, $35(%rip) + LONG $0x29148a43 // movb (%r9,%r13), %dl + WORD $0xfa80; BYTE $0x0d // cmpb $13, %dl + LONG $0x0016840f; WORD $0x0000 // je LBB28_51, $22(%rip) + WORD $0xfa80; BYTE $0x20 // cmpb $32, %dl + LONG $0x000d840f; WORD $0x0000 // je LBB28_51, $13(%rip) + WORD $0xc280; BYTE $0xf7 // addb $-9, %dl + WORD $0xfa80; BYTE $0x01 // cmpb $1, %dl + LONG $0x0093870f; WORD $0x0000 // ja LBB28_60, $147(%rip) + BYTE $0x90 // .p2align 4, 0x90 + +LBB28_51: + LONG $0x04508d48 // leaq $4(%rax), %rdx + WORD $0x3948; BYTE $0xd1 // cmpq %rdx, %rcx + LONG $0x0ada860f; WORD $0x0000 // jbe LBB28_242, $2778(%rip) + WORD $0x3948; BYTE $0xd1 // cmpq %rdx, %rcx + LONG $0x004a840f; WORD $0x0000 // je LBB28_57, $74(%rip) + LONG $0x09148d49 // leaq (%r9,%rcx), %rdx + LONG $0x04c68348 // addq $4, %rsi + LONG $0x016c8d4d; BYTE $0x05 // leaq $5(%r9,%rax), %r13 + QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB28_54: + LONG $0x7dbe0f41; BYTE $0xff // movsbl $-1(%r13), %edi + WORD $0xff83; BYTE $0x20 // cmpl $32, %edi + LONG $0x0042870f; WORD $0x0000 // ja LBB28_59, $66(%rip) + LONG $0xfca30f49 // btq %rdi, %r12 + LONG $0x0038830f; WORD $0x0000 // jae LBB28_59, $56(%rip) + WORD $0xff49; BYTE $0xc5 // incq %r13 + WORD $0xff48; BYTE $0xc6 // incq %rsi + LONG $0xffdc850f; WORD $0xffff // jne LBB28_54, $-36(%rip) + LONG $0x00000ae9; BYTE $0x00 // jmp LBB28_58, $10(%rip) + LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + +LBB28_57: + WORD $0x014c; BYTE $0xca // addq %r9, %rdx + +LBB28_58: + WORD $0x294c; BYTE $0xca // subq %r9, %rdx + WORD $0x8949; BYTE $0xd5 // movq %rdx, %r13 + WORD $0x3949; BYTE $0xcd // cmpq %rcx, %r13 + LONG $0x0020820f; WORD $0x0000 // jb LBB28_60, $32(%rip) + LONG $0x000a76e9; BYTE $0x00 // jmp LBB28_244, $2678(%rip) + QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB28_59: + WORD $0x894c; BYTE $0xca // movq %r9, %rdx + WORD $0xf748; BYTE $0xd2 // notq %rdx + WORD $0x0149; BYTE $0xd5 // addq %rdx, %r13 + WORD $0x3949; BYTE $0xcd // cmpq %rcx, %r13 + LONG $0x0a5b830f; WORD $0x0000 // jae LBB28_244, $2651(%rip) + +LBB28_60: + LONG $0x015d8d49 // leaq $1(%r13), %rbx + WORD $0x8949; BYTE $0x1f // movq %rbx, (%r15) + LONG $0x290c8a43 // movb (%r9,%r13), %cl + WORD $0xf980; BYTE $0x22 // cmpb $34, %cl + LONG $0x0a88850f; WORD $0x0000 // jne LBB28_249, $2696(%rip) + LONG $0xb8458b48 // movq $-72(%rbp), %rax + LONG $0x08408b48 // movq $8(%rax), %rax + WORD $0x8b4c; BYTE $0x30 // movq (%rax), %r14 LONG $0x08788b4c // movq $8(%rax), %r15 QUAD $0xffffffffb045c748 // movq $-1, $-80(%rbp) - WORD $0x894c; BYTE $0xe3 // movq %r12, %rbx - LONG $0x24248b4d // movq (%r12), %r12 - WORD $0x894c; BYTE $0xf7 // movq %r14, %rdi - WORD $0x894c; BYTE $0xe6 // movq %r12, %rsi + WORD $0x894c; BYTE $0xdf // movq %r11, %rdi + WORD $0x8948; BYTE $0xde // movq %rbx, %rsi LONG $0xb0558d48 // leaq $-80(%rbp), %rdx - LONG $0x001aa0e8; BYTE $0x00 // callq _advance_string_default, $6816(%rip) + LONG $0x002254e8; BYTE $0x00 // callq _advance_string_default, $8788(%rip) WORD $0x8548; BYTE $0xc0 // testq %rax, %rax - LONG $0x0312880f; WORD $0x0000 // js LBB33_56, $786(%rip) - WORD $0x8948; BYTE $0x03 // movq %rax, (%rbx) + LONG $0x0a77880f; WORD $0x0000 // js LBB28_252, $2679(%rip) + LONG $0xd04d8b48 // movq $-48(%rbp), %rcx + WORD $0x8948; BYTE $0x01 // movq %rax, (%rcx) LONG $0xb04d8b48 // movq $-80(%rbp), %rcx LONG $0xfff98348 // cmpq $-1, %rcx - LONG $0x0009840f; WORD $0x0000 // je LBB33_8, $9(%rip) + LONG $0x0009840f; WORD $0x0000 // je LBB28_64, $9(%rip) WORD $0x3948; BYTE $0xc1 // cmpq %rax, %rcx - LONG $0x01478e0f; WORD $0x0000 // jle LBB33_27, $327(%rip) + LONG $0x01418e0f; WORD $0x0000 // jle LBB28_84, $321(%rip) -LBB33_8: - WORD $0x894c; BYTE $0xe1 // movq %r12, %rcx - WORD $0xf748; BYTE $0xd1 // notq %rcx - WORD $0x0148; BYTE $0xc8 // addq %rcx, %rax - WORD $0x394c; BYTE $0xf8 // cmpq %r15, %rax - LONG $0x0047850f; WORD $0x0000 // jne LBB33_12, $71(%rip) - WORD $0x034d; BYTE $0x26 // addq (%r14), %r12 - WORD $0x894c; BYTE $0xe9 // movq %r13, %rcx - WORD $0x894c; BYTE $0xe0 // movq %r12, %rax - WORD $0x9090 // .p2align 4, 0x90 +LBB28_64: + WORD $0x8948; BYTE $0xc2 // movq %rax, %rdx + WORD $0x294c; BYTE $0xea // subq %r13, %rdx + LONG $0xfec28348 // addq $-2, %rdx + LONG $0x0001ba41; WORD $0x0000 // movl $1, %r10d + WORD $0x8948; BYTE $0xd1 // movq %rdx, %rcx + WORD $0x094c; BYTE $0xf9 // orq %r15, %rcx + LONG $0xc05d8b4c // movq $-64(%rbp), %r11 + LONG $0x00e0840f; WORD $0x0000 // je LBB28_79, $224(%rip) + WORD $0x394c; BYTE $0xfa // cmpq %r15, %rdx + LONG $0x00d4850f; WORD $0x0000 // jne LBB28_78, $212(%rip) + WORD $0x0349; BYTE $0x1b // addq (%r11), %rbx + LONG $0x10ff8349 // cmpq $16, %r15 + LONG $0x0038820f; WORD $0x0000 // jb LBB28_69, $56(%rip) + LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 -LBB33_10: - LONG $0x10ff8349 // cmpq $16, %r15 - LONG $0x0086820f; WORD $0x0000 // jb LBB33_17, $134(%rip) - LONG $0x006f0ff3 // movdqu (%rax), %xmm0 - LONG $0x6f0f41f3; WORD $0x004d // movdqu (%r13), %xmm1 +LBB28_67: + LONG $0x036f0ff3 // movdqu (%rbx), %xmm0 + LONG $0x6f0f41f3; BYTE $0x0e // movdqu (%r14), %xmm1 LONG $0xc8740f66 // pcmpeqb %xmm0, %xmm1 - LONG $0xd1d70f66 // pmovmskb %xmm1, %edx - LONG $0x10c08348 // addq $16, %rax - LONG $0x10c58349 // addq $16, %r13 + LONG $0xc9d70f66 // pmovmskb %xmm1, %ecx + LONG $0xfff98366 // cmpw $-1, %cx + LONG $0x00a5850f; WORD $0x0000 // jne LBB28_78, $165(%rip) + LONG $0x10c38348 // addq $16, %rbx + LONG $0x10c68349 // addq $16, %r14 LONG $0xf0c78349 // addq $-16, %r15 - LONG $0x10c18348 // addq $16, %rcx - LONG $0x10c48349 // addq $16, %r12 - LONG $0xfffffa81; WORD $0x0000 // cmpl $65535, %edx - LONG $0xffc4840f; WORD $0xffff // je LBB33_10, $-60(%rip) + LONG $0x0fff8349 // cmpq $15, %r15 + LONG $0xffcf870f; WORD $0xffff // ja LBB28_67, $-49(%rip) -LBB33_12: - WORD $0xdb31 // xorl %ebx, %ebx +LBB28_69: + WORD $0x8944; BYTE $0xf1 // movl %r14d, %ecx + LONG $0x0fffe181; WORD $0x0000 // andl $4095, %ecx + LONG $0x0ff0f981; WORD $0x0000 // cmpl $4080, %ecx + LONG $0x0046870f; WORD $0x0000 // ja LBB28_73, $70(%rip) + WORD $0xd989 // movl %ebx, %ecx + LONG $0x0fffe181; WORD $0x0000 // andl $4095, %ecx + LONG $0x0ff1f981; WORD $0x0000 // cmpl $4081, %ecx + LONG $0x0032830f; WORD $0x0000 // jae LBB28_73, $50(%rip) + LONG $0x036f0ff3 // movdqu (%rbx), %xmm0 + LONG $0x6f0f41f3; BYTE $0x0e // movdqu (%r14), %xmm1 + LONG $0xc8740f66 // pcmpeqb %xmm0, %xmm1 + LONG $0xc9d70f66 // pmovmskb %xmm1, %ecx + LONG $0xfff98366 // cmpw $-1, %cx + WORD $0x940f; BYTE $0xc2 // sete %dl + WORD $0xd1f7 // notl %ecx + WORD $0xb70f; BYTE $0xc9 // movzwl %cx, %ecx + LONG $0xc9bc0f48 // bsfq %rcx, %rcx + WORD $0x394c; BYTE $0xf9 // cmpq %r15, %rcx + WORD $0x930f; BYTE $0xc1 // setae %cl + WORD $0xd108 // orb %dl, %cl + LONG $0xd1b60f44 // movzbl %cl, %r10d + LONG $0x000037e9; BYTE $0x00 // jmp LBB28_79, $55(%rip) -LBB33_13: - LONG $0xc8658b4c // movq $-56(%rbp), %r12 +LBB28_73: + WORD $0x854d; BYTE $0xff // testq %r15, %r15 + LONG $0x002e840f; WORD $0x0000 // je LBB28_79, $46(%rip) + WORD $0xd231 // xorl %edx, %edx + QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90 -LBB33_14: - LONG $0xd07d8b4c // movq $-48(%rbp), %r15 - WORD $0x8b49; BYTE $0x3e // movq (%r14), %rdi - LONG $0x08768b49 // movq $8(%r14), %rsi - WORD $0x894c; BYTE $0xe2 // movq %r12, %rdx - LONG $0xffd13be8; BYTE $0xff // callq _advance_ns, $-11973(%rip) - WORD $0x3a3c // cmpb $58, %al - LONG $0x0264850f; WORD $0x0000 // jne LBB33_54, $612(%rip) - WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx - LONG $0x023a850f; WORD $0x0000 // jne LBB33_52, $570(%rip) - WORD $0x894c; BYTE $0xf7 // movq %r14, %rdi - WORD $0x894c; BYTE $0xe6 // movq %r12, %rsi - LONG $0xfff0dfe8; BYTE $0xff // callq _skip_one_fast, $-3873(%rip) - WORD $0x8b49; BYTE $0x3e // movq (%r14), %rdi - LONG $0x08768b49 // movq $8(%r14), %rsi - WORD $0x894c; BYTE $0xe2 // movq %r12, %rdx - LONG $0xffd110e8; BYTE $0xff // callq _advance_ns, $-12016(%rip) - WORD $0x2c3c // cmpb $44, %al - LONG $0xfef8840f; WORD $0xffff // je LBB33_4, $-264(%rip) - LONG $0x000234e9; BYTE $0x00 // jmp LBB33_54, $564(%rip) - WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 +LBB28_75: + LONG $0x130cb60f // movzbl (%rbx,%rdx), %ecx + LONG $0x160c3a41 // cmpb (%r14,%rdx), %cl + LONG $0x0012850f; WORD $0x0000 // jne LBB28_78, $18(%rip) + WORD $0xff48; BYTE $0xc2 // incq %rdx + WORD $0x3949; BYTE $0xd7 // cmpq %rdx, %r15 + LONG $0xffe6850f; WORD $0xffff // jne LBB28_75, $-26(%rip) + LONG $0x000004e9; BYTE $0x00 // jmp LBB28_79, $4(%rip) + BYTE $0x90 // .p2align 4, 0x90 -LBB33_17: - LONG $0xffe48141; WORD $0x000f; BYTE $0x00 // andl $4095, %r12d - LONG $0xf0fc8141; WORD $0x000f; BYTE $0x00 // cmpl $4080, %r12d - LONG $0x0048870f; WORD $0x0000 // ja LBB33_21, $72(%rip) - LONG $0x0fffe181; WORD $0x0000 // andl $4095, %ecx - LONG $0x0ff1f981; WORD $0x0000 // cmpl $4081, %ecx - LONG $0x0036830f; WORD $0x0000 // jae LBB33_21, $54(%rip) - LONG $0x006f0ff3 // movdqu (%rax), %xmm0 - LONG $0x6f0f41f3; WORD $0x004d // movdqu (%r13), %xmm1 - LONG $0xc8740f66 // pcmpeqb %xmm0, %xmm1 - LONG $0xc1d70f66 // pmovmskb %xmm1, %eax - LONG $0xfff88366 // cmpw $-1, %ax - LONG $0xc8658b4c // movq $-56(%rbp), %r12 - LONG $0x004a840f; WORD $0x0000 // je LBB33_25, $74(%rip) - WORD $0xd0f7 // notl %eax - LONG $0xc0bc0f66 // bsfw %ax, %ax - WORD $0xb70f; BYTE $0xc0 // movzwl %ax, %eax - WORD $0xdb31 // xorl %ebx, %ebx - WORD $0x3949; BYTE $0xc7 // cmpq %rax, %r15 - WORD $0x960f; BYTE $0xc3 // setbe %bl - LONG $0xffff56e9; BYTE $0xff // jmp LBB33_14, $-170(%rip) +LBB28_78: + WORD $0x3145; BYTE $0xd2 // xorl %r10d, %r10d -LBB33_21: - LONG $0x000001bb; BYTE $0x00 // movl $1, %ebx +LBB28_79: + WORD $0x8b4d; BYTE $0x0b // movq (%r11), %r9 + LONG $0xd07d8b4c // movq $-48(%rbp), %r15 + LONG $0x08738b49 // movq $8(%r11), %rsi + WORD $0x8948; BYTE $0xc7 // movq %rax, %rdi + WORD $0x2948; BYTE $0xf7 // subq %rsi, %rdi + LONG $0x03f6830f; WORD $0x0000 // jae LBB28_129, $1014(%rip) + +LBB28_80: + LONG $0x01148a41 // movb (%r9,%rax), %dl + WORD $0xfa80; BYTE $0x0d // cmpb $13, %dl + LONG $0x03e9840f; WORD $0x0000 // je LBB28_129, $1001(%rip) + WORD $0xfa80; BYTE $0x20 // cmpb $32, %dl + LONG $0x03e0840f; WORD $0x0000 // je LBB28_129, $992(%rip) + WORD $0xc280; BYTE $0xf7 // addb $-9, %dl + WORD $0xfa80; BYTE $0x01 // cmpb $1, %dl + LONG $0x03d4860f; WORD $0x0000 // jbe LBB28_129, $980(%rip) + WORD $0x8948; BYTE $0xc3 // movq %rax, %rbx + LONG $0x0004eee9; BYTE $0x00 // jmp LBB28_150, $1262(%rip) + +LBB28_84: + QUAD $0x00000000c845c748 // movq $0, $-56(%rbp) + LONG $0xc04d8b48 // movq $-64(%rbp), %rcx + WORD $0x8b4c; BYTE $0x09 // movq (%rcx), %r9 + WORD $0x014c; BYTE $0xcb // addq %r9, %rbx + LONG $0x01448d4d; BYTE $0xff // leaq $-1(%r9,%rax), %r8 + LONG $0x3e1c8d4f // leaq (%r14,%r15), %r11 WORD $0x854d; BYTE $0xff // testq %r15, %r15 - LONG $0xc8658b4c // movq $-56(%rbp), %r12 - LONG $0xff44840f; WORD $0xffff // je LBB33_14, $-188(%rip) - WORD $0xc931 // xorl %ecx, %ecx + LONG $0x037e8e0f; WORD $0x0000 // jle LBB28_126, $894(%rip) + WORD $0x3949; BYTE $0xd8 // cmpq %rbx, %r8 + LONG $0xd07d8b4c // movq $-48(%rbp), %r15 + LONG $0x0375860f; WORD $0x0000 // jbe LBB28_127, $885(%rip) + +LBB28_86: + WORD $0x0b8a // movb (%rbx), %cl + WORD $0xf980; BYTE $0x5c // cmpb $92, %cl + LONG $0x0058850f; WORD $0x0000 // jne LBB28_91, $88(%rip) + WORD $0x894c; BYTE $0xc2 // movq %r8, %rdx + WORD $0x2948; BYTE $0xda // subq %rbx, %rdx + LONG $0xffc1c748; WORD $0xffff; BYTE $0xff // movq $-1, %rcx + WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx + LONG $0x09038e0f; WORD $0x0000 // jle LBB28_256, $2307(%rip) + LONG $0x0173b60f // movzbl $1(%rbx), %esi + LONG $0xaf3d8d48; WORD $0x0098; BYTE $0x00 // leaq $39087(%rip), %rdi /* __UnquoteTab(%rip) */ + LONG $0x3e3c8a44 // movb (%rsi,%rdi), %r15b + LONG $0xffff8041 // cmpb $-1, %r15b + LONG $0x003d840f; WORD $0x0000 // je LBB28_93, $61(%rip) + WORD $0x8445; BYTE $0xff // testb %r15b, %r15b + LONG $0x08cf840f; WORD $0x0000 // je LBB28_254, $2255(%rip) + LONG $0xc87d8844 // movb %r15b, $-56(%rbp) + LONG $0x02c38348 // addq $2, %rbx + LONG $0x000001ba; BYTE $0x00 // movl $1, %edx + LONG $0x15548d4c; BYTE $0xc8 // leaq $-56(%rbp,%rdx), %r10 + WORD $0x394d; BYTE $0xde // cmpq %r11, %r14 + LONG $0x0130820f; WORD $0x0000 // jb LBB28_104, $304(%rip) + LONG $0x0002e6e9; BYTE $0x00 // jmp LBB28_110, $742(%rip) + +LBB28_91: + WORD $0x3a41; BYTE $0x0e // cmpb (%r14), %cl + LONG $0x05c6850f; WORD $0x0000 // jne LBB28_180, $1478(%rip) + WORD $0xff48; BYTE $0xc3 // incq %rbx + WORD $0xff49; BYTE $0xc6 // incq %r14 + LONG $0x0002e3e9; BYTE $0x00 // jmp LBB28_112, $739(%rip) - // .p2align 4, 0x90 -LBB33_23: - LONG $0x0814b60f // movzbl (%rax,%rcx), %edx - LONG $0x0d543a41; BYTE $0x00 // cmpb (%r13,%rcx), %dl - LONG $0x011d850f; WORD $0x0000 // jne LBB33_26, $285(%rip) - WORD $0xff48; BYTE $0xc1 // incq %rcx - WORD $0x3949; BYTE $0xcf // cmpq %rcx, %r15 - LONG $0xffe5850f; WORD $0xffff // jne LBB33_23, $-27(%rip) - LONG $0xffff22e9; BYTE $0xff // jmp LBB33_14, $-222(%rip) +LBB28_93: + LONG $0x03fa8348 // cmpq $3, %rdx + LONG $0x08a08e0f; WORD $0x0000 // jle LBB28_255, $2208(%rip) + WORD $0x4b8b; BYTE $0x02 // movl $2(%rbx), %ecx + WORD $0xce89 // movl %ecx, %esi + WORD $0xd6f7 // notl %esi + LONG $0xcfd0b98d; WORD $0xcfcf // leal $-808464432(%rcx), %edi + LONG $0x8080e681; WORD $0x8080 // andl $-2139062144, %esi + WORD $0xfe85 // testl %edi, %esi + LONG $0x0866850f; WORD $0x0000 // jne LBB28_253, $2150(%rip) + LONG $0x1919b98d; WORD $0x1919 // leal $421075225(%rcx), %edi + WORD $0xcf09 // orl %ecx, %edi + LONG $0x8080c7f7; WORD $0x8080 // testl $-2139062144, %edi + LONG $0x0852850f; WORD $0x0000 // jne LBB28_253, $2130(%rip) + WORD $0xcf89 // movl %ecx, %edi + LONG $0x7f7fe781; WORD $0x7f7f // andl $2139062143, %edi + LONG $0xc0c0ba41; WORD $0xc0c0 // movl $-1061109568, %r10d + WORD $0x2941; BYTE $0xfa // subl %edi, %r10d + LONG $0x46bf8d44; WORD $0x4646; BYTE $0x46 // leal $1179010630(%rdi), %r15d + WORD $0x2141; BYTE $0xf2 // andl %esi, %r10d + WORD $0x8545; BYTE $0xfa // testl %r15d, %r10d + LONG $0x082e850f; WORD $0x0000 // jne LBB28_253, $2094(%rip) + LONG $0xe0e0ba41; WORD $0xe0e0 // movl $-522133280, %r10d + WORD $0x2941; BYTE $0xfa // subl %edi, %r10d + LONG $0x3939c781; WORD $0x3939 // addl $960051513, %edi + WORD $0x2144; BYTE $0xd6 // andl %r10d, %esi + WORD $0xfe85 // testl %edi, %esi + LONG $0x0814850f; WORD $0x0000 // jne LBB28_253, $2068(%rip) + WORD $0xc90f // bswapl %ecx + WORD $0xce89 // movl %ecx, %esi + WORD $0xeec1; BYTE $0x04 // shrl $4, %esi + WORD $0xd6f7 // notl %esi + LONG $0x0101e681; WORD $0x0101 // andl $16843009, %esi + WORD $0x348d; BYTE $0xf6 // leal (%rsi,%rsi,8), %esi + LONG $0x0f0fe181; WORD $0x0f0f // andl $252645135, %ecx + WORD $0xf101 // addl %esi, %ecx + WORD $0x8941; BYTE $0xcf // movl %ecx, %r15d + LONG $0x04efc141 // shrl $4, %r15d + WORD $0x0941; BYTE $0xcf // orl %ecx, %r15d + WORD $0x8944; BYTE $0xfe // movl %r15d, %esi + WORD $0xeec1; BYTE $0x08 // shrl $8, %esi + LONG $0xff00e681; WORD $0x0000 // andl $65280, %esi + LONG $0xcfb60f41 // movzbl %r15b, %ecx + WORD $0xf109 // orl %esi, %ecx + LONG $0x06538d4c // leaq $6(%rbx), %r10 + WORD $0xf983; BYTE $0x7f // cmpl $127, %ecx + LONG $0x00b2860f; WORD $0x0000 // jbe LBB28_114, $178(%rip) + LONG $0x07fff981; WORD $0x0000 // cmpl $2047, %ecx + LONG $0x00b4860f; WORD $0x0000 // jbe LBB28_115, $180(%rip) + WORD $0x8944; BYTE $0xff // movl %r15d, %edi + LONG $0x0000e781; WORD $0x00f8 // andl $16252928, %edi + LONG $0x0000ff81; WORD $0x00d8 // cmpl $14155776, %edi + LONG $0x00c1840f; WORD $0x0000 // je LBB28_116, $193(%rip) + WORD $0xeec1; BYTE $0x0c // shrl $12, %esi + LONG $0xe0ce8040 // orb $-32, %sil + LONG $0xc8758840 // movb %sil, $-56(%rbp) + WORD $0xe9c1; BYTE $0x06 // shrl $6, %ecx + WORD $0xe180; BYTE $0x3f // andb $63, %cl + WORD $0xc980; BYTE $0x80 // orb $-128, %cl + WORD $0x4d88; BYTE $0xc9 // movb %cl, $-55(%rbp) + LONG $0x3fe78041 // andb $63, %r15b + LONG $0x80cf8041 // orb $-128, %r15b + LONG $0xca7d8844 // movb %r15b, $-54(%rbp) + LONG $0x000003ba; BYTE $0x00 // movl $3, %edx + WORD $0x8941; BYTE $0xf7 // movl %esi, %r15d -LBB33_25: - LONG $0x000001bb; BYTE $0x00 // movl $1, %ebx - LONG $0xffff18e9; BYTE $0xff // jmp LBB33_14, $-232(%rip) +LBB28_102: + WORD $0x894c; BYTE $0xd3 // movq %r10, %rbx + LONG $0x15548d4c; BYTE $0xc8 // leaq $-56(%rbp,%rdx), %r10 + WORD $0x394d; BYTE $0xde // cmpq %r11, %r14 + LONG $0x01bb830f; WORD $0x0000 // jae LBB28_110, $443(%rip) + +LBB28_104: + LONG $0xc84d8d48 // leaq $-56(%rbp), %rcx + WORD $0x3949; BYTE $0xca // cmpq %rcx, %r10 + LONG $0x01ae860f; WORD $0x0000 // jbe LBB28_110, $430(%rip) + WORD $0x3845; BYTE $0x3e // cmpb %r15b, (%r14) + LONG $0x01a5850f; WORD $0x0000 // jne LBB28_110, $421(%rip) + WORD $0xff49; BYTE $0xc6 // incq %r14 + LONG $0xc9758d48 // leaq $-55(%rbp), %rsi + WORD $0x894c; BYTE $0xf7 // movq %r14, %rdi + LONG $0xd07d8b4c // movq $-48(%rbp), %r15 -LBB33_27: - QUAD $0x00000000b845c748 // movq $0, $-72(%rbp) - WORD $0x8b49; BYTE $0x0e // movq (%r14), %rcx - WORD $0x0149; BYTE $0xcc // addq %rcx, %r12 - LONG $0xc065894c // movq %r12, $-64(%rbp) - LONG $0x01348d48 // leaq (%rcx,%rax), %rsi - WORD $0xff48; BYTE $0xce // decq %rsi - LONG $0x2f3c8d4b // leaq (%r15,%r13), %rdi - WORD $0x3949; BYTE $0xf4 // cmpq %rsi, %r12 - LONG $0x00c9830f; WORD $0x0000 // jae LBB33_44, $201(%rip) - WORD $0x854d; BYTE $0xff // testq %r15, %r15 - LONG $0x00c08e0f; WORD $0x0000 // jle LBB33_44, $192(%rip) - LONG $0xb8558d48 // leaq $-72(%rbp), %rdx - LONG $0xa8758948 // movq %rsi, $-88(%rbp) +LBB28_107: + WORD $0x8949; BYTE $0xfe // movq %rdi, %r14 + WORD $0x8948; BYTE $0xf2 // movq %rsi, %rdx + WORD $0x394c; BYTE $0xd6 // cmpq %r10, %rsi + LONG $0x0190830f; WORD $0x0000 // jae LBB28_111, $400(%rip) + WORD $0x394d; BYTE $0xde // cmpq %r11, %r14 + LONG $0x0187830f; WORD $0x0000 // jae LBB28_111, $391(%rip) + LONG $0x0eb60f41 // movzbl (%r14), %ecx + LONG $0x017e8d49 // leaq $1(%r14), %rdi + LONG $0x01728d48 // leaq $1(%rdx), %rsi + WORD $0x0a3a // cmpb (%rdx), %cl + LONG $0xffd4840f; WORD $0xffff // je LBB28_107, $-44(%rip) + LONG $0x00016ee9; BYTE $0x00 // jmp LBB28_111, $366(%rip) + +LBB28_114: + LONG $0xc87d8844 // movb %r15b, $-56(%rbp) + LONG $0x000001ba; BYTE $0x00 // movl $1, %edx + LONG $0xffff8ce9; BYTE $0xff // jmp LBB28_102, $-116(%rip) + +LBB28_115: + WORD $0xe9c1; BYTE $0x06 // shrl $6, %ecx + WORD $0xc980; BYTE $0xc0 // orb $-64, %cl + WORD $0x4d88; BYTE $0xc8 // movb %cl, $-56(%rbp) + LONG $0x3fe78041 // andb $63, %r15b + LONG $0x80cf8041 // orb $-128, %r15b + LONG $0xc97d8844 // movb %r15b, $-55(%rbp) + LONG $0x000002ba; BYTE $0x00 // movl $2, %edx + WORD $0x8941; BYTE $0xcf // movl %ecx, %r15d + LONG $0xffff6ae9; BYTE $0xff // jmp LBB28_102, $-150(%rip) + +LBB28_116: + LONG $0x06fa8348 // cmpq $6, %rdx + LONG $0x07228c0f; WORD $0x0000 // jl LBB28_258, $1826(%rip) + LONG $0xdbfff981; WORD $0x0000 // cmpl $56319, %ecx + LONG $0x0716870f; WORD $0x0000 // ja LBB28_258, $1814(%rip) + LONG $0x5c3a8041 // cmpb $92, (%r10) + LONG $0x070c850f; WORD $0x0000 // jne LBB28_258, $1804(%rip) + LONG $0x75077b80 // cmpb $117, $7(%rbx) + LONG $0x0702850f; WORD $0x0000 // jne LBB28_258, $1794(%rip) + LONG $0x08538d4c // leaq $8(%rbx), %r10 + WORD $0x538b; BYTE $0x08 // movl $8(%rbx), %edx + WORD $0xd789 // movl %edx, %edi + WORD $0xd7f7 // notl %edi + LONG $0xcfd0b28d; WORD $0xcfcf // leal $-808464432(%rdx), %esi + LONG $0x8080e781; WORD $0x8080 // andl $-2139062144, %edi + WORD $0xf785 // testl %esi, %edi + LONG $0x06d7850f; WORD $0x0000 // jne LBB28_257, $1751(%rip) + LONG $0x1919b28d; WORD $0x1919 // leal $421075225(%rdx), %esi + WORD $0xd609 // orl %edx, %esi + LONG $0x8080c6f7; WORD $0x8080 // testl $-2139062144, %esi + LONG $0x06c3850f; WORD $0x0000 // jne LBB28_257, $1731(%rip) + WORD $0xd689 // movl %edx, %esi + LONG $0x7f7fe681; WORD $0x7f7f // andl $2139062143, %esi + LONG $0xc0c0bf41; WORD $0xc0c0 // movl $-1061109568, %r15d + WORD $0x2941; BYTE $0xf7 // subl %esi, %r15d + LONG $0x46ae8d44; WORD $0x4646; BYTE $0x46 // leal $1179010630(%rsi), %r13d + WORD $0x2141; BYTE $0xff // andl %edi, %r15d + WORD $0x8545; BYTE $0xef // testl %r13d, %r15d + LONG $0x069f850f; WORD $0x0000 // jne LBB28_257, $1695(%rip) + LONG $0xe0e0bf41; WORD $0xe0e0 // movl $-522133280, %r15d + WORD $0x2941; BYTE $0xf7 // subl %esi, %r15d + LONG $0x3939c681; WORD $0x3939 // addl $960051513, %esi + WORD $0x2144; BYTE $0xff // andl %r15d, %edi + WORD $0xf785 // testl %esi, %edi + LONG $0x0685850f; WORD $0x0000 // jne LBB28_257, $1669(%rip) + WORD $0xca0f // bswapl %edx + WORD $0xd689 // movl %edx, %esi + WORD $0xeec1; BYTE $0x04 // shrl $4, %esi + WORD $0xd6f7 // notl %esi + LONG $0x0101e681; WORD $0x0101 // andl $16843009, %esi + WORD $0x348d; BYTE $0xf6 // leal (%rsi,%rsi,8), %esi + LONG $0x0f0fe281; WORD $0x0f0f // andl $252645135, %edx + WORD $0xf201 // addl %esi, %edx + WORD $0xd689 // movl %edx, %esi + WORD $0xeec1; BYTE $0x04 // shrl $4, %esi + WORD $0xd609 // orl %edx, %esi + WORD $0xf289 // movl %esi, %edx + LONG $0x0000e281; WORD $0x00fc // andl $16515072, %edx + LONG $0x0000fa81; WORD $0x00dc // cmpl $14417920, %edx + LONG $0x065c850f; WORD $0x0000 // jne LBB28_258, $1628(%rip) + WORD $0xf289 // movl %esi, %edx + WORD $0xeac1; BYTE $0x08 // shrl $8, %edx + LONG $0xff00e281; WORD $0x0000 // andl $65280, %edx + LONG $0xf6b60f40 // movzbl %sil, %esi + WORD $0xd609 // orl %edx, %esi + WORD $0xe1c1; BYTE $0x0a // shll $10, %ecx + LONG $0x00318c8d; WORD $0xa024; BYTE $0xfc // leal $-56613888(%rcx,%rsi), %ecx + WORD $0x8941; BYTE $0xcf // movl %ecx, %r15d + LONG $0x12efc141 // shrl $18, %r15d + LONG $0xf0cf8041 // orb $-16, %r15b + LONG $0xc87d8844 // movb %r15b, $-56(%rbp) + WORD $0xca89 // movl %ecx, %edx + WORD $0xeac1; BYTE $0x0c // shrl $12, %edx + WORD $0xe280; BYTE $0x3f // andb $63, %dl + WORD $0xca80; BYTE $0x80 // orb $-128, %dl + WORD $0x5588; BYTE $0xc9 // movb %dl, $-55(%rbp) + WORD $0xca89 // movl %ecx, %edx + WORD $0xeac1; BYTE $0x06 // shrl $6, %edx + WORD $0xe280; BYTE $0x3f // andb $63, %dl + WORD $0xca80; BYTE $0x80 // orb $-128, %dl + WORD $0x5588; BYTE $0xca // movb %dl, $-54(%rbp) + WORD $0xe180; BYTE $0x3f // andb $63, %cl + WORD $0xc980; BYTE $0x80 // orb $-128, %cl + WORD $0x4d88; BYTE $0xcb // movb %cl, $-53(%rbp) + LONG $0x0cc38348 // addq $12, %rbx + LONG $0x000004ba; BYTE $0x00 // movl $4, %edx + LONG $0x15548d4c; BYTE $0xc8 // leaq $-56(%rbp,%rdx), %r10 + WORD $0x394d; BYTE $0xde // cmpq %r11, %r14 + LONG $0xfe45820f; WORD $0xffff // jb LBB28_104, $-443(%rip) -LBB33_30: - LONG $0x04b60f41; BYTE $0x24 // movzbl (%r12), %eax - WORD $0x5c3c // cmpb $92, %al - LONG $0x0069850f; WORD $0x0000 // jne LBB33_37, $105(%rip) - WORD $0x8948; BYTE $0xfb // movq %rdi, %rbx - LONG $0xc07d8d48 // leaq $-64(%rbp), %rdi - WORD $0x8949; BYTE $0xd7 // movq %rdx, %r15 - LONG $0x001c93e8; BYTE $0x00 // callq _unescape, $7315(%rip) - WORD $0x8548; BYTE $0xc0 // testq %rax, %rax - LONG $0x0168880f; WORD $0x0000 // js LBB33_57, $360(%rip) - LONG $0x280c8d48 // leaq (%rax,%rbp), %rcx - LONG $0xb8c18348 // addq $-72, %rcx - WORD $0x8948; BYTE $0xdf // movq %rbx, %rdi - WORD $0x3949; BYTE $0xdd // cmpq %rbx, %r13 - LONG $0xc8658b4c // movq $-56(%rbp), %r12 - LONG $0x0052830f; WORD $0x0000 // jae LBB33_39, $82(%rip) - WORD $0x8548; BYTE $0xc0 // testq %rax, %rax - WORD $0x894c; BYTE $0xfa // movq %r15, %rdx - WORD $0x894c; BYTE $0xf8 // movq %r15, %rax - LONG $0x0049840f; WORD $0x0000 // je LBB33_40, $73(%rip) +LBB28_110: + LONG $0xc8558d48 // leaq $-56(%rbp), %rdx + LONG $0xd07d8b4c // movq $-48(%rbp), %r15 -LBB33_34: - LONG $0x5db60f41; BYTE $0x00 // movzbl (%r13), %ebx - WORD $0x183a // cmpb (%rax), %bl - LONG $0x003c850f; WORD $0x0000 // jne LBB33_40, $60(%rip) - WORD $0xff49; BYTE $0xc5 // incq %r13 - WORD $0xff48; BYTE $0xc0 // incq %rax - WORD $0x3949; BYTE $0xfd // cmpq %rdi, %r13 - LONG $0x002d830f; WORD $0x0000 // jae LBB33_40, $45(%rip) - WORD $0x3948; BYTE $0xc8 // cmpq %rcx, %rax - LONG $0xffdb820f; WORD $0xffff // jb LBB33_34, $-37(%rip) - LONG $0x00001fe9; BYTE $0x00 // jmp LBB33_40, $31(%rip) +LBB28_111: + WORD $0x394c; BYTE $0xd2 // cmpq %r10, %rdx + LONG $0x02d8850f; WORD $0x0000 // jne LBB28_180, $728(%rip) -LBB33_37: - LONG $0x00453a41 // cmpb (%r13), %al - LONG $0xfe5b850f; WORD $0xffff // jne LBB33_12, $-421(%rip) - WORD $0xff49; BYTE $0xc4 // incq %r12 - LONG $0xc065894c // movq %r12, $-64(%rbp) - WORD $0xff49; BYTE $0xc5 // incq %r13 - LONG $0x000017e9; BYTE $0x00 // jmp LBB33_42, $23(%rip) +LBB28_112: + WORD $0x3949; BYTE $0xd8 // cmpq %rbx, %r8 + LONG $0x0012860f; WORD $0x0000 // jbe LBB28_127, $18(%rip) + WORD $0x394d; BYTE $0xde // cmpq %r11, %r14 + LONG $0xfc94820f; WORD $0xffff // jb LBB28_86, $-876(%rip) + LONG $0x000004e9; BYTE $0x00 // jmp LBB28_127, $4(%rip) + +LBB28_126: + LONG $0xd07d8b4c // movq $-48(%rbp), %r15 + +LBB28_127: + WORD $0x3149; BYTE $0xd8 // xorq %rbx, %r8 + WORD $0x314d; BYTE $0xde // xorq %r11, %r14 + WORD $0x3145; BYTE $0xd2 // xorl %r10d, %r10d + WORD $0x094d; BYTE $0xc6 // orq %r8, %r14 + LONG $0xc2940f41 // sete %r10b + +LBB28_128: + LONG $0xc05d8b4c // movq $-64(%rbp), %r11 + LONG $0x08738b49 // movq $8(%r11), %rsi + WORD $0x8948; BYTE $0xc7 // movq %rax, %rdi + WORD $0x2948; BYTE $0xf7 // subq %rsi, %rdi + LONG $0xfc0c820f; WORD $0xffff // jb LBB28_80, $-1012(%rip) + WORD $0x9090 // .p2align 4, 0x90 -LBB33_39: - WORD $0x894c; BYTE $0xfa // movq %r15, %rdx - WORD $0x894c; BYTE $0xf8 // movq %r15, %rax +LBB28_129: + LONG $0x01588d48 // leaq $1(%rax), %rbx + WORD $0x3948; BYTE $0xf3 // cmpq %rsi, %rbx + LONG $0x0023830f; WORD $0x0000 // jae LBB28_133, $35(%rip) + LONG $0x19148a41 // movb (%r9,%rbx), %dl + WORD $0xfa80; BYTE $0x0d // cmpb $13, %dl + LONG $0x0016840f; WORD $0x0000 // je LBB28_133, $22(%rip) + WORD $0xfa80; BYTE $0x20 // cmpb $32, %dl + LONG $0x000d840f; WORD $0x0000 // je LBB28_133, $13(%rip) + WORD $0xc280; BYTE $0xf7 // addb $-9, %dl + WORD $0xfa80; BYTE $0x01 // cmpb $1, %dl + LONG $0x00f3870f; WORD $0x0000 // ja LBB28_150, $243(%rip) + BYTE $0x90 // .p2align 4, 0x90 -LBB33_40: - WORD $0x3948; BYTE $0xc8 // cmpq %rcx, %rax - LONG $0x002d850f; WORD $0x0000 // jne LBB33_26, $45(%rip) - LONG $0xc0658b4c // movq $-64(%rbp), %r12 - LONG $0xa8758b48 // movq $-88(%rbp), %rsi - -LBB33_42: - WORD $0x3949; BYTE $0xf4 // cmpq %rsi, %r12 - LONG $0x0009830f; WORD $0x0000 // jae LBB33_44, $9(%rip) - WORD $0x3949; BYTE $0xfd // cmpq %rdi, %r13 - LONG $0xff48820f; WORD $0xffff // jb LBB33_30, $-184(%rip) - -LBB33_44: - WORD $0x3149; BYTE $0xf4 // xorq %rsi, %r12 - WORD $0x3149; BYTE $0xfd // xorq %rdi, %r13 - WORD $0xdb31 // xorl %ebx, %ebx - WORD $0x094d; BYTE $0xe5 // orq %r12, %r13 - WORD $0x940f; BYTE $0xc3 // sete %bl - LONG $0xfffe12e9; BYTE $0xff // jmp LBB33_13, $-494(%rip) +LBB28_133: + LONG $0x02588d48 // leaq $2(%rax), %rbx + WORD $0x3948; BYTE $0xf3 // cmpq %rsi, %rbx + LONG $0x0023830f; WORD $0x0000 // jae LBB28_137, $35(%rip) + LONG $0x19148a41 // movb (%r9,%rbx), %dl + WORD $0xfa80; BYTE $0x0d // cmpb $13, %dl + LONG $0x0016840f; WORD $0x0000 // je LBB28_137, $22(%rip) + WORD $0xfa80; BYTE $0x20 // cmpb $32, %dl + LONG $0x000d840f; WORD $0x0000 // je LBB28_137, $13(%rip) + WORD $0xc280; BYTE $0xf7 // addb $-9, %dl + WORD $0xfa80; BYTE $0x01 // cmpb $1, %dl + LONG $0x00c3870f; WORD $0x0000 // ja LBB28_150, $195(%rip) + BYTE $0x90 // .p2align 4, 0x90 + +LBB28_137: + LONG $0x03588d48 // leaq $3(%rax), %rbx + WORD $0x3948; BYTE $0xf3 // cmpq %rsi, %rbx + LONG $0x0023830f; WORD $0x0000 // jae LBB28_141, $35(%rip) + LONG $0x19148a41 // movb (%r9,%rbx), %dl + WORD $0xfa80; BYTE $0x0d // cmpb $13, %dl + LONG $0x0016840f; WORD $0x0000 // je LBB28_141, $22(%rip) + WORD $0xfa80; BYTE $0x20 // cmpb $32, %dl + LONG $0x000d840f; WORD $0x0000 // je LBB28_141, $13(%rip) + WORD $0xc280; BYTE $0xf7 // addb $-9, %dl + WORD $0xfa80; BYTE $0x01 // cmpb $1, %dl + LONG $0x0093870f; WORD $0x0000 // ja LBB28_150, $147(%rip) + BYTE $0x90 // .p2align 4, 0x90 -LBB33_26: - WORD $0xdb31 // xorl %ebx, %ebx - LONG $0xfffe0fe9; BYTE $0xff // jmp LBB33_14, $-497(%rip) +LBB28_141: + LONG $0x04508d48 // leaq $4(%rax), %rdx + WORD $0x3948; BYTE $0xd6 // cmpq %rdx, %rsi + LONG $0x044a860f; WORD $0x0000 // jbe LBB28_242, $1098(%rip) + WORD $0x3948; BYTE $0xd6 // cmpq %rdx, %rsi + LONG $0x004a840f; WORD $0x0000 // je LBB28_147, $74(%rip) + LONG $0x31148d49 // leaq (%r9,%rsi), %rdx + LONG $0x04c78348 // addq $4, %rdi + LONG $0x015c8d49; BYTE $0x05 // leaq $5(%r9,%rax), %rbx QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 -LBB33_47: - WORD $0xf980; BYTE $0x02 // cmpb $2, %cl - LONG $0x0078850f; WORD $0x0000 // jne LBB33_54, $120(%rip) - WORD $0x5b3c // cmpb $91, %al - LONG $0x0070850f; WORD $0x0000 // jne LBB33_54, $112(%rip) - LONG $0x08478b49 // movq $8(%r15), %rax - WORD $0x8b48; BYTE $0x18 // movq (%rax), %rbx +LBB28_144: + LONG $0xff4bbe0f // movsbl $-1(%rbx), %ecx + WORD $0xf983; BYTE $0x20 // cmpl $32, %ecx + LONG $0x0043870f; WORD $0x0000 // ja LBB28_149, $67(%rip) + LONG $0xcca30f49 // btq %rcx, %r12 + LONG $0x0039830f; WORD $0x0000 // jae LBB28_149, $57(%rip) WORD $0xff48; BYTE $0xc3 // incq %rbx - LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 + WORD $0xff48; BYTE $0xc7 // incq %rdi + LONG $0xffdd850f; WORD $0xffff // jne LBB28_144, $-35(%rip) + LONG $0x00000be9; BYTE $0x00 // jmp LBB28_148, $11(%rip) + QUAD $0x9090909090909090 // .p2align 4, 0x90 + +LBB28_147: + WORD $0x014c; BYTE $0xca // addq %r9, %rdx + +LBB28_148: + WORD $0x294c; BYTE $0xca // subq %r9, %rdx + WORD $0x8948; BYTE $0xd3 // movq %rdx, %rbx + WORD $0x3948; BYTE $0xf3 // cmpq %rsi, %rbx + LONG $0x0020820f; WORD $0x0000 // jb LBB28_150, $32(%rip) + LONG $0x0003e6e9; BYTE $0x00 // jmp LBB28_244, $998(%rip) + QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB28_149: + WORD $0x894c; BYTE $0xc9 // movq %r9, %rcx + WORD $0xf748; BYTE $0xd1 // notq %rcx + WORD $0x0148; BYTE $0xcb // addq %rcx, %rbx + WORD $0x3948; BYTE $0xf3 // cmpq %rsi, %rbx + LONG $0x03cb830f; WORD $0x0000 // jae LBB28_244, $971(%rip) + +LBB28_150: + LONG $0x01538d48 // leaq $1(%rbx), %rdx + WORD $0x8949; BYTE $0x17 // movq %rdx, (%r15) + LONG $0x193c8041; BYTE $0x3a // cmpb $58, (%r9,%rbx) + LONG $0x03b6850f; WORD $0x0000 // jne LBB28_243, $950(%rip) + WORD $0x854d; BYTE $0xd2 // testq %r10, %r10 + LONG $0x0369850f; WORD $0x0000 // jne LBB28_240, $873(%rip) + WORD $0x894c; BYTE $0xdf // movq %r11, %rdi + WORD $0x894c; BYTE $0xfe // movq %r15, %rsi + LONG $0xffe528e8; BYTE $0xff // callq _skip_one_fast, $-6872(%rip) + LONG $0xc05d8b4c // movq $-64(%rbp), %r11 + WORD $0x8b4d; BYTE $0x0b // movq (%r11), %r9 + LONG $0x084b8b49 // movq $8(%r11), %rcx + WORD $0x8b49; BYTE $0x07 // movq (%r15), %rax + WORD $0x8948; BYTE $0xc6 // movq %rax, %rsi + WORD $0x2948; BYTE $0xce // subq %rcx, %rsi + LONG $0x002e830f; WORD $0x0000 // jae LBB28_157, $46(%rip) + LONG $0x01148a41 // movb (%r9,%rax), %dl + WORD $0xfa80; BYTE $0x0d // cmpb $13, %dl + LONG $0x0021840f; WORD $0x0000 // je LBB28_157, $33(%rip) + WORD $0xfa80; BYTE $0x20 // cmpb $32, %dl + LONG $0x0018840f; WORD $0x0000 // je LBB28_157, $24(%rip) + WORD $0xc280; BYTE $0xf7 // addb $-9, %dl + WORD $0xfa80; BYTE $0x01 // cmpb $1, %dl + LONG $0x000c860f; WORD $0x0000 // jbe LBB28_157, $12(%rip) + WORD $0x8948; BYTE $0xc7 // movq %rax, %rdi + LONG $0xfff78ee9; BYTE $0xff // jmp LBB28_178, $-2162(%rip) + LONG $0x90909090 // .p2align 4, 0x90 -LBB33_50: - WORD $0xff48; BYTE $0xcb // decq %rbx - WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx - LONG $0x00348e0f; WORD $0x0000 // jle LBB33_52, $52(%rip) - WORD $0x894c; BYTE $0xf7 // movq %r14, %rdi - WORD $0x894c; BYTE $0xe6 // movq %r12, %rsi - LONG $0xffeed9e8; BYTE $0xff // callq _skip_one_fast, $-4391(%rip) - WORD $0x8b49; BYTE $0x3e // movq (%r14), %rdi - LONG $0x08768b49 // movq $8(%r14), %rsi - WORD $0x894c; BYTE $0xe2 // movq %r12, %rdx - LONG $0xffcf0ae8; BYTE $0xff // callq _advance_ns, $-12534(%rip) - WORD $0x2c3c // cmpb $44, %al - LONG $0xffd2840f; WORD $0xffff // je LBB33_50, $-46(%rip) - LONG $0x00002ee9; BYTE $0x00 // jmp LBB33_54, $46(%rip) +LBB28_157: + LONG $0x01788d48 // leaq $1(%rax), %rdi + WORD $0x3948; BYTE $0xcf // cmpq %rcx, %rdi + LONG $0x0023830f; WORD $0x0000 // jae LBB28_161, $35(%rip) + LONG $0x39148a41 // movb (%r9,%rdi), %dl + WORD $0xfa80; BYTE $0x0d // cmpb $13, %dl + LONG $0x0016840f; WORD $0x0000 // je LBB28_161, $22(%rip) + WORD $0xfa80; BYTE $0x20 // cmpb $32, %dl + LONG $0x000d840f; WORD $0x0000 // je LBB28_161, $13(%rip) + WORD $0xc280; BYTE $0xf7 // addb $-9, %dl + WORD $0xfa80; BYTE $0x01 // cmpb $1, %dl + LONG $0xf75b870f; WORD $0xffff // ja LBB28_178, $-2213(%rip) + BYTE $0x90 // .p2align 4, 0x90 + +LBB28_161: + LONG $0x02788d48 // leaq $2(%rax), %rdi + WORD $0x3948; BYTE $0xcf // cmpq %rcx, %rdi + LONG $0x0023830f; WORD $0x0000 // jae LBB28_165, $35(%rip) + LONG $0x39148a41 // movb (%r9,%rdi), %dl + WORD $0xfa80; BYTE $0x0d // cmpb $13, %dl + LONG $0x0016840f; WORD $0x0000 // je LBB28_165, $22(%rip) + WORD $0xfa80; BYTE $0x20 // cmpb $32, %dl + LONG $0x000d840f; WORD $0x0000 // je LBB28_165, $13(%rip) + WORD $0xc280; BYTE $0xf7 // addb $-9, %dl + WORD $0xfa80; BYTE $0x01 // cmpb $1, %dl + LONG $0xf72b870f; WORD $0xffff // ja LBB28_178, $-2261(%rip) + BYTE $0x90 // .p2align 4, 0x90 + +LBB28_165: + LONG $0x03788d48 // leaq $3(%rax), %rdi + WORD $0x3948; BYTE $0xcf // cmpq %rcx, %rdi + LONG $0x0023830f; WORD $0x0000 // jae LBB28_169, $35(%rip) + LONG $0x39148a41 // movb (%r9,%rdi), %dl + WORD $0xfa80; BYTE $0x0d // cmpb $13, %dl + LONG $0x0016840f; WORD $0x0000 // je LBB28_169, $22(%rip) + WORD $0xfa80; BYTE $0x20 // cmpb $32, %dl + LONG $0x000d840f; WORD $0x0000 // je LBB28_169, $13(%rip) + WORD $0xc280; BYTE $0xf7 // addb $-9, %dl + WORD $0xfa80; BYTE $0x01 // cmpb $1, %dl + LONG $0xf6fb870f; WORD $0xffff // ja LBB28_178, $-2309(%rip) + BYTE $0x90 // .p2align 4, 0x90 + +LBB28_169: + LONG $0x04508d48 // leaq $4(%rax), %rdx + WORD $0x3948; BYTE $0xd1 // cmpq %rdx, %rcx + LONG $0x02ba860f; WORD $0x0000 // jbe LBB28_242, $698(%rip) + WORD $0x3948; BYTE $0xd1 // cmpq %rdx, %rcx + LONG $0x004a840f; WORD $0x0000 // je LBB28_175, $74(%rip) + LONG $0x09148d49 // leaq (%r9,%rcx), %rdx + LONG $0x04c68348 // addq $4, %rsi + LONG $0x017c8d49; BYTE $0x05 // leaq $5(%r9,%rax), %rdi QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 -LBB33_52: - LONG $0x10c78349 // addq $16, %r15 - LONG $0xa0458b48 // movq $-96(%rbp), %rax - WORD $0x3949; BYTE $0xc7 // cmpq %rax, %r15 - LONG $0xfc91850f; WORD $0xffff // jne LBB33_2, $-879(%rip) - -LBB33_53: - WORD $0x894c; BYTE $0xf7 // movq %r14, %rdi - WORD $0x894c; BYTE $0xe6 // movq %r12, %rsi - LONG $0xffee94e8; BYTE $0xff // callq _skip_one_fast, $-4460(%rip) - LONG $0x00000be9; BYTE $0x00 // jmp LBB33_55, $11(%rip) - -LBB33_54: - LONG $0x240cff49 // decq (%r12) - LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq $-2, %rax +LBB28_172: + LONG $0xff5fbe0f // movsbl $-1(%rdi), %ebx + WORD $0xfb83; BYTE $0x20 // cmpl $32, %ebx + LONG $0xf6ab870f; WORD $0xffff // ja LBB28_177, $-2389(%rip) + LONG $0xdca30f49 // btq %rbx, %r12 + LONG $0xf6a1830f; WORD $0xffff // jae LBB28_177, $-2399(%rip) + WORD $0xff48; BYTE $0xc7 // incq %rdi + WORD $0xff48; BYTE $0xc6 // incq %rsi + LONG $0xffdd850f; WORD $0xffff // jne LBB28_172, $-35(%rip) + LONG $0x00000be9; BYTE $0x00 // jmp LBB28_176, $11(%rip) + QUAD $0x9090909090909090 // .p2align 4, 0x90 -LBB33_55: - LONG $0x38c48348 // addq $56, %rsp - BYTE $0x5b // popq %rbx - WORD $0x5c41 // popq %r12 - WORD $0x5d41 // popq %r13 - WORD $0x5e41 // popq %r14 - WORD $0x5f41 // popq %r15 - BYTE $0x5d // popq %rbp - BYTE $0xc3 // retq +LBB28_175: + WORD $0x014c; BYTE $0xca // addq %r9, %rdx -LBB33_56: - LONG $0x08468b49 // movq $8(%r14), %rax - WORD $0x8948; BYTE $0x03 // movq %rax, (%rbx) - LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax - LONG $0xffffdee9; BYTE $0xff // jmp LBB33_55, $-34(%rip) - -LBB33_57: - LONG $0xc04d8b48 // movq $-64(%rbp), %rcx - WORD $0x2b49; BYTE $0x0e // subq (%r14), %rcx - LONG $0xc8558b48 // movq $-56(%rbp), %rdx - WORD $0x8948; BYTE $0x0a // movq %rcx, (%rdx) - LONG $0xffffcbe9; BYTE $0xff // jmp LBB33_55, $-53(%rip) - QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 +LBB28_176: + WORD $0x294c; BYTE $0xca // subq %r9, %rdx + WORD $0x8948; BYTE $0xd7 // movq %rdx, %rdi + WORD $0x3948; BYTE $0xcf // cmpq %rcx, %rdi + LONG $0xf688820f; WORD $0xffff // jb LBB28_178, $-2424(%rip) + LONG $0x000256e9; BYTE $0x00 // jmp LBB28_244, $598(%rip) + +LBB28_180: + WORD $0x3145; BYTE $0xd2 // xorl %r10d, %r10d + LONG $0xfffd4be9; BYTE $0xff // jmp LBB28_128, $-693(%rip) + +LBB28_206: + WORD $0x8949; BYTE $0x17 // movq %rdx, (%r15) + WORD $0x8948; BYTE $0xd0 // movq %rdx, %rax + LONG $0x000052e9; BYTE $0x00 // jmp LBB28_211, $82(%rip) + +LBB28_29: + WORD $0x894c; BYTE $0xc8 // movq %r9, %rax + WORD $0xf748; BYTE $0xd0 // notq %rax + WORD $0x0148; BYTE $0xc6 // addq %rax, %rsi + WORD $0x394c; BYTE $0xc6 // cmpq %r8, %rsi + LONG $0xf456820f; WORD $0xffff // jb LBB28_28, $-2986(%rip) + LONG $0xfff4abe9; BYTE $0xff // jmp LBB28_30, $-2901(%rip) + +LBB28_207: + WORD $0x014c; BYTE $0xca // addq %r9, %rdx + +LBB28_208: + WORD $0x294c; BYTE $0xca // subq %r9, %rdx + WORD $0x8948; BYTE $0xd7 // movq %rdx, %rdi + WORD $0x394c; BYTE $0xc7 // cmpq %r8, %rdi + LONG $0x0017820f; WORD $0x0000 // jb LBB28_210, $23(%rip) + LONG $0x000024e9; BYTE $0x00 // jmp LBB28_211, $36(%rip) + +LBB28_209: + WORD $0x894c; BYTE $0xc9 // movq %r9, %rcx + WORD $0xf748; BYTE $0xd1 // notq %rcx + WORD $0x0148; BYTE $0xcf // addq %rcx, %rdi + WORD $0x394c; BYTE $0xc7 // cmpq %r8, %rdi + LONG $0x0012830f; WORD $0x0000 // jae LBB28_211, $18(%rip) + +LBB28_210: + LONG $0x01478d48 // leaq $1(%rdi), %rax + WORD $0x8949; BYTE $0x07 // movq %rax, (%r15) + LONG $0x393c8041; BYTE $0x5d // cmpb $93, (%r9,%rdi) + LONG $0x023e840f; WORD $0x0000 // je LBB28_251, $574(%rip) + +LBB28_211: + WORD $0xff48; BYTE $0xc8 // decq %rax + WORD $0x8949; BYTE $0x07 // movq %rax, (%r15) + WORD $0x8948; BYTE $0xc2 // movq %rax, %rdx + WORD $0x854d; BYTE $0xf6 // testq %r14, %r14 + LONG $0x01988e0f; WORD $0x0000 // jle LBB28_240, $408(%rip) + WORD $0x9090 // .p2align 4, 0x90 + +LBB28_212: + WORD $0x894c; BYTE $0xdf // movq %r11, %rdi + WORD $0x894c; BYTE $0xfe // movq %r15, %rsi + LONG $0xffe355e8; BYTE $0xff // callq _skip_one_fast, $-7339(%rip) + LONG $0xc05d8b4c // movq $-64(%rbp), %r11 + WORD $0x8b4d; BYTE $0x0b // movq (%r11), %r9 + LONG $0x084b8b49 // movq $8(%r11), %rcx + WORD $0x8b49; BYTE $0x07 // movq (%r15), %rax + WORD $0x8948; BYTE $0xc6 // movq %rax, %rsi + WORD $0x2948; BYTE $0xce // subq %rcx, %rsi + LONG $0x002b830f; WORD $0x0000 // jae LBB28_217, $43(%rip) + LONG $0x01148a41 // movb (%r9,%rax), %dl + WORD $0xfa80; BYTE $0x0d // cmpb $13, %dl + LONG $0x001e840f; WORD $0x0000 // je LBB28_217, $30(%rip) + WORD $0xfa80; BYTE $0x20 // cmpb $32, %dl + LONG $0x0015840f; WORD $0x0000 // je LBB28_217, $21(%rip) + WORD $0xc280; BYTE $0xf7 // addb $-9, %dl + WORD $0xfa80; BYTE $0x01 // cmpb $1, %dl + LONG $0x0009860f; WORD $0x0000 // jbe LBB28_217, $9(%rip) + WORD $0x8948; BYTE $0xc7 // movq %rax, %rdi + LONG $0x000123e9; BYTE $0x00 // jmp LBB28_238, $291(%rip) + BYTE $0x90 // .p2align 4, 0x90 + +LBB28_217: + LONG $0x01788d48 // leaq $1(%rax), %rdi + WORD $0x3948; BYTE $0xcf // cmpq %rcx, %rdi + LONG $0x0023830f; WORD $0x0000 // jae LBB28_221, $35(%rip) + LONG $0x39148a41 // movb (%r9,%rdi), %dl + WORD $0xfa80; BYTE $0x0d // cmpb $13, %dl + LONG $0x0016840f; WORD $0x0000 // je LBB28_221, $22(%rip) + WORD $0xfa80; BYTE $0x20 // cmpb $32, %dl + LONG $0x000d840f; WORD $0x0000 // je LBB28_221, $13(%rip) + WORD $0xc280; BYTE $0xf7 // addb $-9, %dl + WORD $0xfa80; BYTE $0x01 // cmpb $1, %dl + LONG $0x00f3870f; WORD $0x0000 // ja LBB28_238, $243(%rip) + BYTE $0x90 // .p2align 4, 0x90 + +LBB28_221: + LONG $0x02788d48 // leaq $2(%rax), %rdi + WORD $0x3948; BYTE $0xcf // cmpq %rcx, %rdi + LONG $0x0023830f; WORD $0x0000 // jae LBB28_225, $35(%rip) + LONG $0x39148a41 // movb (%r9,%rdi), %dl + WORD $0xfa80; BYTE $0x0d // cmpb $13, %dl + LONG $0x0016840f; WORD $0x0000 // je LBB28_225, $22(%rip) + WORD $0xfa80; BYTE $0x20 // cmpb $32, %dl + LONG $0x000d840f; WORD $0x0000 // je LBB28_225, $13(%rip) + WORD $0xc280; BYTE $0xf7 // addb $-9, %dl + WORD $0xfa80; BYTE $0x01 // cmpb $1, %dl + LONG $0x00c3870f; WORD $0x0000 // ja LBB28_238, $195(%rip) + BYTE $0x90 // .p2align 4, 0x90 + +LBB28_225: + LONG $0x03788d48 // leaq $3(%rax), %rdi + WORD $0x3948; BYTE $0xcf // cmpq %rcx, %rdi + LONG $0x0023830f; WORD $0x0000 // jae LBB28_229, $35(%rip) + LONG $0x39148a41 // movb (%r9,%rdi), %dl + WORD $0xfa80; BYTE $0x0d // cmpb $13, %dl + LONG $0x0016840f; WORD $0x0000 // je LBB28_229, $22(%rip) + WORD $0xfa80; BYTE $0x20 // cmpb $32, %dl + LONG $0x000d840f; WORD $0x0000 // je LBB28_229, $13(%rip) + WORD $0xc280; BYTE $0xf7 // addb $-9, %dl + WORD $0xfa80; BYTE $0x01 // cmpb $1, %dl + LONG $0x0093870f; WORD $0x0000 // ja LBB28_238, $147(%rip) + BYTE $0x90 // .p2align 4, 0x90 + +LBB28_229: + LONG $0x04508d48 // leaq $4(%rax), %rdx + WORD $0x3948; BYTE $0xd1 // cmpq %rdx, %rcx + LONG $0x00ea860f; WORD $0x0000 // jbe LBB28_242, $234(%rip) + WORD $0x3948; BYTE $0xd1 // cmpq %rdx, %rcx + LONG $0x004a840f; WORD $0x0000 // je LBB28_235, $74(%rip) + LONG $0x09148d49 // leaq (%r9,%rcx), %rdx + LONG $0x04c68348 // addq $4, %rsi + LONG $0x017c8d49; BYTE $0x05 // leaq $5(%r9,%rax), %rdi + QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB28_232: + LONG $0xff5fbe0f // movsbl $-1(%rdi), %ebx + WORD $0xfb83; BYTE $0x20 // cmpl $32, %ebx + LONG $0x0043870f; WORD $0x0000 // ja LBB28_237, $67(%rip) + LONG $0xdca30f49 // btq %rbx, %r12 + LONG $0x0039830f; WORD $0x0000 // jae LBB28_237, $57(%rip) + WORD $0xff48; BYTE $0xc7 // incq %rdi + WORD $0xff48; BYTE $0xc6 // incq %rsi + LONG $0xffdd850f; WORD $0xffff // jne LBB28_232, $-35(%rip) + LONG $0x00000be9; BYTE $0x00 // jmp LBB28_236, $11(%rip) + QUAD $0x9090909090909090 // .p2align 4, 0x90 + +LBB28_235: + WORD $0x014c; BYTE $0xca // addq %r9, %rdx + +LBB28_236: + WORD $0x294c; BYTE $0xca // subq %r9, %rdx + WORD $0x8948; BYTE $0xd7 // movq %rdx, %rdi + WORD $0x3948; BYTE $0xcf // cmpq %rcx, %rdi + LONG $0x0020820f; WORD $0x0000 // jb LBB28_238, $32(%rip) + LONG $0x000086e9; BYTE $0x00 // jmp LBB28_244, $134(%rip) + QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90 + +LBB28_237: + WORD $0x894c; BYTE $0xca // movq %r9, %rdx + WORD $0xf748; BYTE $0xd2 // notq %rdx + WORD $0x0148; BYTE $0xd7 // addq %rdx, %rdi + WORD $0x3948; BYTE $0xcf // cmpq %rcx, %rdi + LONG $0x006b830f; WORD $0x0000 // jae LBB28_244, $107(%rip) + +LBB28_238: + LONG $0x01578d48 // leaq $1(%rdi), %rdx + WORD $0x8949; BYTE $0x17 // movq %rdx, (%r15) + LONG $0x39048a41 // movb (%r9,%rdi), %al + WORD $0x2c3c // cmpb $44, %al + LONG $0x0077850f; WORD $0x0000 // jne LBB28_246, $119(%rip) + LONG $0xff468d49 // leaq $-1(%r14), %rax + LONG $0x02fe8349 // cmpq $2, %r14 + WORD $0x8949; BYTE $0xc6 // movq %rax, %r14 + LONG $0xfe6a8d0f; WORD $0xffff // jge LBB28_212, $-406(%rip) + +LBB28_240: + LONG $0xb8458b48 // movq $-72(%rbp), %rax + LONG $0x10c08348 // addq $16, %rax + LONG $0xa8558b4c // movq $-88(%rbp), %r10 + LONG $0xb8458948 // movq %rax, $-72(%rbp) + WORD $0x394c; BYTE $0xd0 // cmpq %r10, %rax + LONG $0xa04d8b48 // movq $-96(%rbp), %rcx + LONG $0xf11b850f; WORD $0xffff // jne LBB28_2, $-3813(%rip) + +LBB28_241: + QUAD $0xfffff0b5056f0f66 // movdqa $-3915(%rip), %xmm0 /* LCPI28_0(%rip) */ + LONG $0x017f0ff3 // movdqu %xmm0, (%rcx) + WORD $0x8948; BYTE $0xcf // movq %rcx, %rdi + WORD $0x894c; BYTE $0xde // movq %r11, %rsi + WORD $0x894c; BYTE $0xfa // movq %r15, %rdx + WORD $0xc931 // xorl %ecx, %ecx + LONG $0xffd081e8; BYTE $0xff // callq _fsm_exec, $-12159(%rip) + WORD $0x8948; BYTE $0xc1 // movq %rax, %rcx + LONG $0x000013e9; BYTE $0x00 // jmp LBB28_245, $19(%rip) + +LBB28_242: + WORD $0x8949; BYTE $0x17 // movq %rdx, (%r15) + +LBB28_243: + WORD $0x8948; BYTE $0xd0 // movq %rdx, %rax + +LBB28_244: + WORD $0xff48; BYTE $0xc8 // decq %rax + WORD $0x8949; BYTE $0x07 // movq %rax, (%r15) + LONG $0xfec1c748; WORD $0xffff; BYTE $0xff // movq $-2, %rcx + +LBB28_245: + WORD $0x8948; BYTE $0xc8 // movq %rcx, %rax + LONG $0x38c48348 // addq $56, %rsp + BYTE $0x5b // popq %rbx + WORD $0x5c41 // popq %r12 + WORD $0x5d41 // popq %r13 + WORD $0x5e41 // popq %r14 + WORD $0x5f41 // popq %r15 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB28_246: + WORD $0x5d3c // cmpb $93, %al + LONG $0xffd6850f; WORD $0xffff // jne LBB28_243, $-42(%rip) + WORD $0x8948; BYTE $0xd0 // movq %rdx, %rax + LONG $0x00001ee9; BYTE $0x00 // jmp LBB28_251, $30(%rip) + +LBB28_248: + WORD $0xff48; BYTE $0xc8 // decq %rax + WORD $0x8949; BYTE $0x07 // movq %rax, (%r15) + LONG $0xdec1c748; WORD $0xffff; BYTE $0xff // movq $-34, %rcx + LONG $0xffffcce9; BYTE $0xff // jmp LBB28_245, $-52(%rip) + +LBB28_249: + WORD $0x8948; BYTE $0xd8 // movq %rbx, %rax + +LBB28_250: + WORD $0xf980; BYTE $0x7d // cmpb $125, %cl + LONG $0xffb3850f; WORD $0xffff // jne LBB28_244, $-77(%rip) + +LBB28_251: + WORD $0xff48; BYTE $0xc8 // decq %rax + WORD $0x8949; BYTE $0x07 // movq %rax, (%r15) + LONG $0xdfc1c748; WORD $0xffff; BYTE $0xff // movq $-33, %rcx + LONG $0xffffaee9; BYTE $0xff // jmp LBB28_245, $-82(%rip) + +LBB28_252: + LONG $0xc0458b48 // movq $-64(%rbp), %rax + LONG $0x08408b48 // movq $8(%rax), %rax + LONG $0xd04d8b48 // movq $-48(%rbp), %rcx + WORD $0x8948; BYTE $0x01 // movq %rax, (%rcx) + LONG $0xffc1c748; WORD $0xffff; BYTE $0xff // movq $-1, %rcx + LONG $0xffff93e9; BYTE $0xff // jmp LBB28_245, $-109(%rip) + +LBB28_253: + LONG $0x02c38348 // addq $2, %rbx + LONG $0xfec1c748; WORD $0xffff; BYTE $0xff // movq $-2, %rcx + LONG $0x000012e9; BYTE $0x00 // jmp LBB28_256, $18(%rip) + +LBB28_254: + WORD $0xff48; BYTE $0xc3 // incq %rbx + LONG $0xfdc1c748; WORD $0xffff; BYTE $0xff // movq $-3, %rcx + LONG $0x000003e9; BYTE $0x00 // jmp LBB28_256, $3(%rip) + +LBB28_255: + WORD $0xff48; BYTE $0xc3 // incq %rbx + +LBB28_256: + LONG $0xd0458b48 // movq $-48(%rbp), %rax + WORD $0x294c; BYTE $0xcb // subq %r9, %rbx + WORD $0x8948; BYTE $0x18 // movq %rbx, (%rax) + LONG $0xffff62e9; BYTE $0xff // jmp LBB28_245, $-158(%rip) + +LBB28_257: + LONG $0xfec1c748; WORD $0xffff; BYTE $0xff // movq $-2, %rcx + LONG $0x000007e9; BYTE $0x00 // jmp LBB28_259, $7(%rip) + +LBB28_258: + LONG $0xfcc1c748; WORD $0xffff; BYTE $0xff // movq $-4, %rcx + +LBB28_259: + WORD $0x894c; BYTE $0xd3 // movq %r10, %rbx + LONG $0xffffd6e9; BYTE $0xff // jmp LBB28_256, $-42(%rip) + QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 _validate_utf8: - BYTE $0x55 // pushq %rbp - WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp - WORD $0x5741 // pushq %r15 - WORD $0x5641 // pushq %r14 - WORD $0x5441 // pushq %r12 - BYTE $0x53 // pushq %rbx - BYTE $0x50 // pushq %rax - WORD $0x8b4c; BYTE $0x17 // movq (%rdi), %r10 - LONG $0x085f8b4c // movq $8(%rdi), %r11 - WORD $0x8b48; BYTE $0x0e // movq (%rsi), %rcx - WORD $0x014c; BYTE $0xd1 // addq %r10, %rcx - LONG $0x1a048d4f // leaq (%r10,%r11), %r8 - LONG $0xfdc08349 // addq $-3, %r8 - LONG $0x00000de9; BYTE $0x00 // jmp LBB34_1, $13(%rip) - QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90 + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + WORD $0x5741 // pushq %r15 + WORD $0x5641 // pushq %r14 + WORD $0x5441 // pushq %r12 + BYTE $0x53 // pushq %rbx + BYTE $0x50 // pushq %rax + WORD $0x8b4c; BYTE $0x17 // movq (%rdi), %r10 + LONG $0x085f8b4c // movq $8(%rdi), %r11 + WORD $0x8b48; BYTE $0x0e // movq (%rsi), %rcx + WORD $0x014c; BYTE $0xd1 // addq %r10, %rcx + LONG $0x1a448d4f; BYTE $0xfd // leaq $-3(%r10,%r11), %r8 + LONG $0x000010e9; BYTE $0x00 // jmp LBB29_1, $16(%rip) + QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 -LBB34_19: +LBB29_19: WORD $0x0148; BYTE $0xd9 // addq %rbx, %rcx -LBB34_1: +LBB29_1: WORD $0x394c; BYTE $0xc1 // cmpq %r8, %rcx - LONG $0x00e1830f; WORD $0x0000 // jae LBB34_2, $225(%rip) + LONG $0x00e1830f; WORD $0x0000 // jae LBB29_2, $225(%rip) LONG $0x000001bb; BYTE $0x00 // movl $1, %ebx WORD $0x3980; BYTE $0x00 // cmpb $0, (%rcx) - LONG $0xffe6890f; WORD $0xffff // jns LBB34_19, $-26(%rip) + LONG $0xffe6890f; WORD $0xffff // jns LBB29_19, $-26(%rip) WORD $0x018b // movl (%rcx), %eax WORD $0xc789 // movl %eax, %edi LONG $0xc0f0e781; WORD $0x00c0 // andl $12632304, %edi LONG $0x80e0ff81; WORD $0x0080 // cmpl $8421600, %edi - LONG $0x0030850f; WORD $0x0000 // jne LBB34_10, $48(%rip) + LONG $0x0030850f; WORD $0x0000 // jne LBB29_10, $48(%rip) WORD $0xc789 // movl %eax, %edi LONG $0x200fe781; WORD $0x0000 // andl $8207, %edi LONG $0x200dff81; WORD $0x0000 // cmpl $8205, %edi - LONG $0x001c840f; WORD $0x0000 // je LBB34_10, $28(%rip) + LONG $0x001c840f; WORD $0x0000 // je LBB29_10, $28(%rip) LONG $0x000003bb; BYTE $0x00 // movl $3, %ebx WORD $0xff85 // testl %edi, %edi - LONG $0xffaf850f; WORD $0xffff // jne LBB34_19, $-81(%rip) + LONG $0xffaf850f; WORD $0xffff // jne LBB29_19, $-81(%rip) QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 -LBB34_10: +LBB29_10: WORD $0xc789 // movl %eax, %edi LONG $0xc0e0e781; WORD $0x0000 // andl $49376, %edi LONG $0x80c0ff81; WORD $0x0000 // cmpl $32960, %edi - LONG $0x0010850f; WORD $0x0000 // jne LBB34_12, $16(%rip) + LONG $0x0010850f; WORD $0x0000 // jne LBB29_12, $16(%rip) WORD $0xc789 // movl %eax, %edi LONG $0x000002bb; BYTE $0x00 // movl $2, %ebx WORD $0xe783; BYTE $0x1e // andl $30, %edi - LONG $0xff7c850f; WORD $0xffff // jne LBB34_19, $-132(%rip) + LONG $0xff7c850f; WORD $0xffff // jne LBB29_19, $-132(%rip) -LBB34_12: +LBB29_12: WORD $0xc789 // movl %eax, %edi LONG $0xc0f8e781; WORD $0xc0c0 // andl $-1061109512, %edi LONG $0x80f0ff81; WORD $0x8080 // cmpl $-2139062032, %edi - LONG $0x0026850f; WORD $0x0000 // jne LBB34_16, $38(%rip) + LONG $0x0026850f; WORD $0x0000 // jne LBB29_16, $38(%rip) WORD $0xc789 // movl %eax, %edi LONG $0x3007e781; WORD $0x0000 // andl $12295, %edi - LONG $0x0018840f; WORD $0x0000 // je LBB34_16, $24(%rip) + LONG $0x0018840f; WORD $0x0000 // je LBB29_16, $24(%rip) LONG $0x000004bb; BYTE $0x00 // movl $4, %ebx WORD $0x04a8 // testb $4, %al - LONG $0xff4d840f; WORD $0xffff // je LBB34_19, $-179(%rip) + LONG $0xff4d840f; WORD $0xffff // je LBB29_19, $-179(%rip) LONG $0x00300325; BYTE $0x00 // andl $12291, %eax - LONG $0xff42840f; WORD $0xffff // je LBB34_19, $-190(%rip) + LONG $0xff42840f; WORD $0xffff // je LBB29_19, $-190(%rip) -LBB34_16: +LBB29_16: WORD $0x8948; BYTE $0xcf // movq %rcx, %rdi WORD $0x294c; BYTE $0xd7 // subq %r10, %rdi WORD $0x8b48; BYTE $0x1a // movq (%rdx), %rbx LONG $0x00fb8148; WORD $0x0010; BYTE $0x00 // cmpq $4096, %rbx - LONG $0x0187830f; WORD $0x0000 // jae LBB34_17, $391(%rip) + LONG $0x0187830f; WORD $0x0000 // jae LBB29_17, $391(%rip) WORD $0x6348; BYTE $0xc7 // movslq %edi, %rax LONG $0x017b8d48 // leaq $1(%rbx), %rdi WORD $0x8948; BYTE $0x3a // movq %rdi, (%rdx) LONG $0xda448948; BYTE $0x08 // movq %rax, $8(%rdx,%rbx,8) LONG $0x000001bb; BYTE $0x00 // movl $1, %ebx - LONG $0xffff13e9; BYTE $0xff // jmp LBB34_19, $-237(%rip) + LONG $0xffff13e9; BYTE $0xff // jmp LBB29_19, $-237(%rip) -LBB34_2: +LBB29_2: WORD $0x014d; BYTE $0xd3 // addq %r10, %r11 WORD $0x394c; BYTE $0xd9 // cmpq %r11, %rcx - LONG $0x013e830f; WORD $0x0000 // jae LBB34_36, $318(%rip) + LONG $0x013e830f; WORD $0x0000 // jae LBB29_36, $318(%rip) LONG $0xdc458d4c // leaq $-36(%rbp), %r8 LONG $0xda4d8d4c // leaq $-38(%rbp), %r9 - LONG $0x000016e9; BYTE $0x00 // jmp LBB34_4, $22(%rip) + LONG $0x000016e9; BYTE $0x00 // jmp LBB29_4, $22(%rip) QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90 -LBB34_5: +LBB29_5: WORD $0xff48; BYTE $0xc1 // incq %rcx WORD $0x394c; BYTE $0xd9 // cmpq %r11, %rcx - LONG $0x011b830f; WORD $0x0000 // jae LBB34_36, $283(%rip) + LONG $0x011b830f; WORD $0x0000 // jae LBB29_36, $283(%rip) -LBB34_4: +LBB29_4: WORD $0x3980; BYTE $0x00 // cmpb $0, (%rcx) - LONG $0xffeb890f; WORD $0xffff // jns LBB34_5, $-21(%rip) + LONG $0xffeb890f; WORD $0xffff // jns LBB29_5, $-21(%rip) LONG $0x00dc45c6 // movb $0, $-36(%rbp) LONG $0x00da45c6 // movb $0, $-38(%rbp) WORD $0x894c; BYTE $0xdb // movq %r11, %rbx WORD $0x2948; BYTE $0xcb // subq %rcx, %rbx LONG $0x02fb8348 // cmpq $2, %rbx - LONG $0x0035820f; WORD $0x0000 // jb LBB34_21, $53(%rip) + LONG $0x0035820f; WORD $0x0000 // jb LBB29_21, $53(%rip) LONG $0x21b60f44 // movzbl (%rcx), %r12d LONG $0x71b60f44; BYTE $0x01 // movzbl $1(%rcx), %r14d LONG $0xdc658844 // movb %r12b, $-36(%rbp) @@ -8255,67 +8957,66 @@ LBB34_4: LONG $0xfec38348 // addq $-2, %rbx WORD $0x894c; BYTE $0xcf // movq %r9, %rdi WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx - LONG $0x0029840f; WORD $0x0000 // je LBB34_24, $41(%rip) + LONG $0x0029840f; WORD $0x0000 // je LBB29_24, $41(%rip) -LBB34_25: +LBB29_25: LONG $0x07b60f41 // movzbl (%r15), %eax WORD $0x0788 // movb %al, (%rdi) LONG $0x65b60f44; BYTE $0xdc // movzbl $-36(%rbp), %r12d LONG $0xda7db60f // movzbl $-38(%rbp), %edi - LONG $0x000017e9; BYTE $0x00 // jmp LBB34_26, $23(%rip) + LONG $0x000017e9; BYTE $0x00 // jmp LBB29_26, $23(%rip) -LBB34_21: +LBB29_21: WORD $0x3145; BYTE $0xe4 // xorl %r12d, %r12d WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d WORD $0x894c; BYTE $0xc7 // movq %r8, %rdi WORD $0x8949; BYTE $0xcf // movq %rcx, %r15 WORD $0x8548; BYTE $0xdb // testq %rbx, %rbx - LONG $0xffd7850f; WORD $0xffff // jne LBB34_25, $-41(%rip) + LONG $0xffd7850f; WORD $0xffff // jne LBB29_25, $-41(%rip) -LBB34_24: +LBB29_24: WORD $0xff31 // xorl %edi, %edi -LBB34_26: +LBB29_26: LONG $0xc7b60f40 // movzbl %dil, %eax WORD $0xe0c1; BYTE $0x10 // shll $16, %eax LONG $0xdeb60f41 // movzbl %r14b, %ebx WORD $0xe3c1; BYTE $0x08 // shll $8, %ebx - WORD $0xc309 // orl %eax, %ebx LONG $0xfcb60f41 // movzbl %r12b, %edi WORD $0xdf09 // orl %ebx, %edi - WORD $0xf889 // movl %edi, %eax + WORD $0xf809 // orl %edi, %eax LONG $0xc0c0f025; BYTE $0x00 // andl $12632304, %eax LONG $0x8080e03d; BYTE $0x00 // cmpl $8421600, %eax - LONG $0x001f850f; WORD $0x0000 // jne LBB34_29, $31(%rip) + LONG $0x0021850f; WORD $0x0000 // jne LBB29_29, $33(%rip) WORD $0xf889 // movl %edi, %eax LONG $0x00200f25; BYTE $0x00 // andl $8207, %eax LONG $0x00200d3d; BYTE $0x00 // cmpl $8205, %eax - LONG $0x000d840f; WORD $0x0000 // je LBB34_29, $13(%rip) + LONG $0x000f840f; WORD $0x0000 // je LBB29_29, $15(%rip) LONG $0x000003bb; BYTE $0x00 // movl $3, %ebx WORD $0xc085 // testl %eax, %eax - LONG $0x0021850f; WORD $0x0000 // jne LBB34_34, $33(%rip) + LONG $0x0023850f; WORD $0x0000 // jne LBB29_34, $35(%rip) + WORD $0x9090 // .p2align 4, 0x90 - // .p2align 4, 0x90 -LBB34_29: +LBB29_29: LONG $0x1ec4f641 // testb $30, %r12b - LONG $0x0028840f; WORD $0x0000 // je LBB34_31, $40(%rip) + LONG $0x0028840f; WORD $0x0000 // je LBB29_31, $40(%rip) LONG $0xc0e0e781; WORD $0x0000 // andl $49376, %edi LONG $0x000002bb; BYTE $0x00 // movl $2, %ebx LONG $0x80c0ff81; WORD $0x0000 // cmpl $32960, %edi - LONG $0x0011850f; WORD $0x0000 // jne LBB34_31, $17(%rip) + LONG $0x0011850f; WORD $0x0000 // jne LBB29_31, $17(%rip) -LBB34_34: +LBB29_34: WORD $0x0148; BYTE $0xd9 // addq %rbx, %rcx WORD $0x394c; BYTE $0xd9 // cmpq %r11, %rcx - LONG $0xff1f820f; WORD $0xffff // jb LBB34_4, $-225(%rip) - LONG $0x000035e9; BYTE $0x00 // jmp LBB34_36, $53(%rip) + LONG $0xff1f820f; WORD $0xffff // jb LBB29_4, $-225(%rip) + LONG $0x000035e9; BYTE $0x00 // jmp LBB29_36, $53(%rip) -LBB34_31: +LBB29_31: WORD $0x8948; BYTE $0xc8 // movq %rcx, %rax WORD $0x294c; BYTE $0xd0 // subq %r10, %rax WORD $0x8b48; BYTE $0x3a // movq (%rdx), %rdi LONG $0x00ff8148; WORD $0x0010; BYTE $0x00 // cmpq $4096, %rdi - LONG $0x0034830f; WORD $0x0000 // jae LBB34_32, $52(%rip) + LONG $0x0034830f; WORD $0x0000 // jae LBB29_32, $52(%rip) WORD $0x9848 // cltq LONG $0x015f8d48 // leaq $1(%rdi), %rbx WORD $0x8948; BYTE $0x1a // movq %rbx, (%rdx) @@ -8323,14 +9024,14 @@ LBB34_31: LONG $0x000001bb; BYTE $0x00 // movl $1, %ebx WORD $0x0148; BYTE $0xd9 // addq %rbx, %rcx WORD $0x394c; BYTE $0xd9 // cmpq %r11, %rcx - LONG $0xfee5820f; WORD $0xffff // jb LBB34_4, $-283(%rip) + LONG $0xfee5820f; WORD $0xffff // jb LBB29_4, $-283(%rip) -LBB34_36: +LBB29_36: WORD $0x294c; BYTE $0xd1 // subq %r10, %rcx WORD $0x8948; BYTE $0x0e // movq %rcx, (%rsi) WORD $0xc031 // xorl %eax, %eax -LBB34_37: +LBB29_37: LONG $0x08c48348 // addq $8, %rsp BYTE $0x5b // popq %rbx WORD $0x5c41 // popq %r12 @@ -8339,81 +9040,80 @@ LBB34_37: BYTE $0x5d // popq %rbp BYTE $0xc3 // retq -LBB34_32: +LBB29_32: WORD $0x8948; BYTE $0x06 // movq %rax, (%rsi) LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax - LONG $0xffffe4e9; BYTE $0xff // jmp LBB34_37, $-28(%rip) + LONG $0xffffe4e9; BYTE $0xff // jmp LBB29_37, $-28(%rip) -LBB34_17: +LBB29_17: WORD $0x8948; BYTE $0x3e // movq %rdi, (%rsi) LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax - LONG $0xffffd5e9; BYTE $0xff // jmp LBB34_37, $-43(%rip) + LONG $0xffffd5e9; BYTE $0xff // jmp LBB29_37, $-43(%rip) LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 _validate_utf8_fast: - BYTE $0x55 // pushq %rbp - WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp - BYTE $0x53 // pushq %rbx - BYTE $0x50 // pushq %rax - WORD $0x8b4c; BYTE $0x17 // movq (%rdi), %r10 - LONG $0x085f8b4c // movq $8(%rdi), %r11 - LONG $0x1a348d4b // leaq (%r10,%r11), %rsi - LONG $0xfdc68348 // addq $-3, %rsi - WORD $0x894c; BYTE $0xd0 // movq %r10, %rax - WORD $0x394c; BYTE $0xd6 // cmpq %r10, %rsi - LONG $0x00dd860f; WORD $0x0000 // jbe LBB35_14, $221(%rip) - WORD $0x894c; BYTE $0xd0 // movq %r10, %rax - LONG $0x000013e9; BYTE $0x00 // jmp LBB35_3, $19(%rip) - LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + BYTE $0x55 // pushq %rbp + WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp + BYTE $0x53 // pushq %rbx + BYTE $0x50 // pushq %rax + WORD $0x8b4c; BYTE $0x17 // movq (%rdi), %r10 + LONG $0x085f8b4c // movq $8(%rdi), %r11 + LONG $0x1a748d4b; BYTE $0xfd // leaq $-3(%r10,%r11), %rsi + WORD $0x894c; BYTE $0xd0 // movq %r10, %rax + WORD $0x3949; BYTE $0xf2 // cmpq %rsi, %r10 + LONG $0x00e0830f; WORD $0x0000 // jae LBB30_14, $224(%rip) + WORD $0x894c; BYTE $0xd0 // movq %r10, %rax + LONG $0x000016e9; BYTE $0x00 // jmp LBB30_3, $22(%rip) + QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90 -LBB35_2: +LBB30_2: WORD $0x0148; BYTE $0xd0 // addq %rdx, %rax WORD $0x3948; BYTE $0xf0 // cmpq %rsi, %rax - LONG $0x00c2830f; WORD $0x0000 // jae LBB35_14, $194(%rip) + LONG $0x00c2830f; WORD $0x0000 // jae LBB30_14, $194(%rip) -LBB35_3: +LBB30_3: LONG $0x000001ba; BYTE $0x00 // movl $1, %edx WORD $0x3880; BYTE $0x00 // cmpb $0, (%rax) - LONG $0xffe6890f; WORD $0xffff // jns LBB35_2, $-26(%rip) + LONG $0xffe6890f; WORD $0xffff // jns LBB30_2, $-26(%rip) WORD $0x388b // movl (%rax), %edi WORD $0xf989 // movl %edi, %ecx LONG $0xc0f0e181; WORD $0x00c0 // andl $12632304, %ecx LONG $0x80e0f981; WORD $0x0080 // cmpl $8421600, %ecx - LONG $0x0030850f; WORD $0x0000 // jne LBB35_7, $48(%rip) + LONG $0x0030850f; WORD $0x0000 // jne LBB30_7, $48(%rip) WORD $0xf989 // movl %edi, %ecx LONG $0x200fe181; WORD $0x0000 // andl $8207, %ecx LONG $0x200df981; WORD $0x0000 // cmpl $8205, %ecx - LONG $0x001c840f; WORD $0x0000 // je LBB35_7, $28(%rip) + LONG $0x001c840f; WORD $0x0000 // je LBB30_7, $28(%rip) LONG $0x000003ba; BYTE $0x00 // movl $3, %edx WORD $0xc985 // testl %ecx, %ecx - LONG $0xffaf850f; WORD $0xffff // jne LBB35_2, $-81(%rip) + LONG $0xffaf850f; WORD $0xffff // jne LBB30_2, $-81(%rip) QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 -LBB35_7: +LBB30_7: WORD $0xf989 // movl %edi, %ecx LONG $0xc0e0e181; WORD $0x0000 // andl $49376, %ecx LONG $0x80c0f981; WORD $0x0000 // cmpl $32960, %ecx - LONG $0x0010850f; WORD $0x0000 // jne LBB35_9, $16(%rip) + LONG $0x0010850f; WORD $0x0000 // jne LBB30_9, $16(%rip) WORD $0xf989 // movl %edi, %ecx LONG $0x000002ba; BYTE $0x00 // movl $2, %edx WORD $0xe183; BYTE $0x1e // andl $30, %ecx - LONG $0xff7c850f; WORD $0xffff // jne LBB35_2, $-132(%rip) + LONG $0xff7c850f; WORD $0xffff // jne LBB30_2, $-132(%rip) -LBB35_9: +LBB30_9: WORD $0xf989 // movl %edi, %ecx LONG $0xc0f8e181; WORD $0xc0c0 // andl $-1061109512, %ecx LONG $0x80f0f981; WORD $0x8080 // cmpl $-2139062032, %ecx - LONG $0x0029850f; WORD $0x0000 // jne LBB35_13, $41(%rip) + LONG $0x0029850f; WORD $0x0000 // jne LBB30_13, $41(%rip) WORD $0xf989 // movl %edi, %ecx LONG $0x3007e181; WORD $0x0000 // andl $12295, %ecx - LONG $0x001b840f; WORD $0x0000 // je LBB35_13, $27(%rip) + LONG $0x001b840f; WORD $0x0000 // je LBB30_13, $27(%rip) LONG $0x000004ba; BYTE $0x00 // movl $4, %edx LONG $0x04c7f640 // testb $4, %dil - LONG $0xff4b840f; WORD $0xffff // je LBB35_2, $-181(%rip) + LONG $0xff4b840f; WORD $0xffff // je LBB30_2, $-181(%rip) LONG $0x3003e781; WORD $0x0000 // andl $12291, %edi - LONG $0xff3f840f; WORD $0xffff // je LBB35_2, $-193(%rip) + LONG $0xff3f840f; WORD $0xffff // je LBB30_2, $-193(%rip) -LBB35_13: +LBB30_13: WORD $0xf748; BYTE $0xd0 // notq %rax WORD $0x014c; BYTE $0xd0 // addq %r10, %rax LONG $0x08c48348 // addq $8, %rsp @@ -8421,29 +9121,29 @@ LBB35_13: BYTE $0x5d // popq %rbp BYTE $0xc3 // retq -LBB35_14: +LBB30_14: WORD $0x014d; BYTE $0xd3 // addq %r10, %r11 WORD $0x394c; BYTE $0xd8 // cmpq %r11, %rax - LONG $0x0103830f; WORD $0x0000 // jae LBB35_30, $259(%rip) + LONG $0x0103830f; WORD $0x0000 // jae LBB30_30, $259(%rip) LONG $0xf4458d4c // leaq $-12(%rbp), %r8 LONG $0xf24d8d4c // leaq $-14(%rbp), %r9 - LONG $0x000015e9; BYTE $0x00 // jmp LBB35_17, $21(%rip) + LONG $0x000015e9; BYTE $0x00 // jmp LBB30_17, $21(%rip) QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90 -LBB35_16: +LBB30_16: WORD $0xff48; BYTE $0xc0 // incq %rax WORD $0x394c; BYTE $0xd8 // cmpq %r11, %rax - LONG $0x00e1830f; WORD $0x0000 // jae LBB35_30, $225(%rip) + LONG $0x00e1830f; WORD $0x0000 // jae LBB30_30, $225(%rip) -LBB35_17: +LBB30_17: WORD $0x3880; BYTE $0x00 // cmpb $0, (%rax) - LONG $0xffeb890f; WORD $0xffff // jns LBB35_16, $-21(%rip) + LONG $0xffeb890f; WORD $0xffff // jns LBB30_16, $-21(%rip) LONG $0x00f445c6 // movb $0, $-12(%rbp) LONG $0x00f245c6 // movb $0, $-14(%rbp) WORD $0x894c; BYTE $0xda // movq %r11, %rdx WORD $0x2948; BYTE $0xc2 // subq %rax, %rdx LONG $0x02fa8348 // cmpq $2, %rdx - LONG $0x0031820f; WORD $0x0000 // jb LBB35_21, $49(%rip) + LONG $0x0031820f; WORD $0x0000 // jb LBB30_21, $49(%rip) WORD $0xb60f; BYTE $0x30 // movzbl (%rax), %esi LONG $0x0178b60f // movzbl $1(%rax), %edi LONG $0xf4758840 // movb %sil, $-12(%rbp) @@ -8451,61 +9151,60 @@ LBB35_17: LONG $0xfec28348 // addq $-2, %rdx WORD $0x894c; BYTE $0xcb // movq %r9, %rbx WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx - LONG $0x0025840f; WORD $0x0000 // je LBB35_22, $37(%rip) + LONG $0x0025840f; WORD $0x0000 // je LBB30_22, $37(%rip) -LBB35_20: +LBB30_20: WORD $0xb60f; BYTE $0x09 // movzbl (%rcx), %ecx WORD $0x0b88 // movb %cl, (%rbx) LONG $0xf475b60f // movzbl $-12(%rbp), %esi LONG $0xf24db60f // movzbl $-14(%rbp), %ecx - LONG $0x000015e9; BYTE $0x00 // jmp LBB35_23, $21(%rip) + LONG $0x000015e9; BYTE $0x00 // jmp LBB30_23, $21(%rip) -LBB35_21: +LBB30_21: WORD $0xf631 // xorl %esi, %esi WORD $0xff31 // xorl %edi, %edi WORD $0x894c; BYTE $0xc3 // movq %r8, %rbx WORD $0x8948; BYTE $0xc1 // movq %rax, %rcx WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx - LONG $0xffdb850f; WORD $0xffff // jne LBB35_20, $-37(%rip) + LONG $0xffdb850f; WORD $0xffff // jne LBB30_20, $-37(%rip) -LBB35_22: +LBB30_22: WORD $0xc931 // xorl %ecx, %ecx -LBB35_23: +LBB30_23: WORD $0xb60f; BYTE $0xc9 // movzbl %cl, %ecx WORD $0xe1c1; BYTE $0x10 // shll $16, %ecx LONG $0xffb60f40 // movzbl %dil, %edi WORD $0xe7c1; BYTE $0x08 // shll $8, %edi - WORD $0xcf09 // orl %ecx, %edi LONG $0xd6b60f40 // movzbl %sil, %edx WORD $0xfa09 // orl %edi, %edx - WORD $0xd189 // movl %edx, %ecx + WORD $0xd109 // orl %edx, %ecx LONG $0xc0f0e181; WORD $0x00c0 // andl $12632304, %ecx LONG $0x80e0f981; WORD $0x0080 // cmpl $8421600, %ecx - LONG $0x0024850f; WORD $0x0000 // jne LBB35_26, $36(%rip) + LONG $0x0026850f; WORD $0x0000 // jne LBB30_26, $38(%rip) WORD $0xd789 // movl %edx, %edi LONG $0x200fe781; WORD $0x0000 // andl $8207, %edi LONG $0x200dff81; WORD $0x0000 // cmpl $8205, %edi - LONG $0x0010840f; WORD $0x0000 // je LBB35_26, $16(%rip) + LONG $0x0012840f; WORD $0x0000 // je LBB30_26, $18(%rip) LONG $0x000003b9; BYTE $0x00 // movl $3, %ecx WORD $0xff85 // testl %edi, %edi - LONG $0x0024850f; WORD $0x0000 // jne LBB35_28, $36(%rip) - WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + LONG $0x0026850f; WORD $0x0000 // jne LBB30_28, $38(%rip) + LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 -LBB35_26: +LBB30_26: LONG $0x1ec6f640 // testb $30, %sil - LONG $0xff07840f; WORD $0xffff // je LBB35_13, $-249(%rip) + LONG $0xff07840f; WORD $0xffff // je LBB30_13, $-249(%rip) LONG $0xc0e0e281; WORD $0x0000 // andl $49376, %edx LONG $0x000002b9; BYTE $0x00 // movl $2, %ecx LONG $0x80c0fa81; WORD $0x0000 // cmpl $32960, %edx - LONG $0xfef0850f; WORD $0xffff // jne LBB35_13, $-272(%rip) + LONG $0xfef0850f; WORD $0xffff // jne LBB30_13, $-272(%rip) -LBB35_28: +LBB30_28: WORD $0x0148; BYTE $0xc8 // addq %rcx, %rax WORD $0x394c; BYTE $0xd8 // cmpq %r11, %rax - LONG $0xff1f820f; WORD $0xffff // jb LBB35_17, $-225(%rip) + LONG $0xff1f820f; WORD $0xffff // jb LBB30_17, $-225(%rip) -LBB35_30: +LBB30_30: WORD $0xc031 // xorl %eax, %eax LONG $0x08c48348 // addq $8, %rsp BYTE $0x5b // popq %rbx @@ -8513,7 +9212,7 @@ LBB35_30: BYTE $0xc3 // retq QUAD $0x0000000000000000; WORD $0x0000 // .p2align 4, 0x00 -LCPI36_0: +LCPI31_0: QUAD $0x3030303030303030; QUAD $0x3030303030303030 // .space 16, '0000000000000000' // .p2align 4, 0x90 @@ -8525,999 +9224,944 @@ _f32toa: WORD $0x5541 // pushq %r13 WORD $0x5441 // pushq %r12 BYTE $0x53 // pushq %rbx - BYTE $0x50 // pushq %rax LONG $0xc07e0f66 // movd %xmm0, %eax WORD $0xc189 // movl %eax, %ecx WORD $0xe9c1; BYTE $0x17 // shrl $23, %ecx - WORD $0xb60f; BYTE $0xd1 // movzbl %cl, %edx - LONG $0x00fffa81; WORD $0x0000 // cmpl $255, %edx - LONG $0x0c90840f; WORD $0x0000 // je LBB36_1, $3216(%rip) + WORD $0xb60f; BYTE $0xd9 // movzbl %cl, %ebx + LONG $0x00fffb81; WORD $0x0000 // cmpl $255, %ebx + LONG $0x0c9e840f; WORD $0x0000 // je LBB31_138, $3230(%rip) WORD $0x07c6; BYTE $0x2d // movb $45, (%rdi) - WORD $0x8941; BYTE $0xc5 // movl %eax, %r13d - LONG $0x1fedc141 // shrl $31, %r13d - LONG $0x2f0c8d4e // leaq (%rdi,%r13), %r9 + WORD $0x8941; BYTE $0xc1 // movl %eax, %r9d + LONG $0x1fe9c141 // shrl $31, %r9d + LONG $0x0f048d4e // leaq (%rdi,%r9), %r8 LONG $0xffffffa9; BYTE $0x7f // testl $2147483647, %eax - LONG $0x0191840f; WORD $0x0000 // je LBB36_3, $401(%rip) + LONG $0x01bf840f; WORD $0x0000 // je LBB31_11, $447(%rip) LONG $0x7fffff25; BYTE $0x00 // andl $8388607, %eax - WORD $0xd285 // testl %edx, %edx - LONG $0x0c71840f; WORD $0x0000 // je LBB36_5, $3185(%rip) - LONG $0x00b88d44; WORD $0x8000; BYTE $0x00 // leal $8388608(%rax), %r15d - LONG $0x6a828d44; WORD $0xffff; BYTE $0xff // leal $-150(%rdx), %r8d - WORD $0x4a8d; BYTE $0x81 // leal $-127(%rdx), %ecx + WORD $0xdb85 // testl %ebx, %ebx + LONG $0x0c80840f; WORD $0x0000 // je LBB31_139, $3200(%rip) + LONG $0x0000b08d; WORD $0x0080 // leal $8388608(%rax), %esi + LONG $0x6abb8d44; WORD $0xffff; BYTE $0xff // leal $-150(%rbx), %r15d + WORD $0x4b8d; BYTE $0x81 // leal $-127(%rbx), %ecx WORD $0xf983; BYTE $0x17 // cmpl $23, %ecx - LONG $0x001c870f; WORD $0x0000 // ja LBB36_6, $28(%rip) - LONG $0x000096b9; BYTE $0x00 // movl $150, %ecx - WORD $0xd129 // subl %edx, %ecx - LONG $0xffc3c748; WORD $0xffff; BYTE $0xff // movq $-1, %rbx - WORD $0xd348; BYTE $0xe3 // shlq %cl, %rbx - WORD $0xd3f7 // notl %ebx - WORD $0x8544; BYTE $0xfb // testl %r15d, %ebx - LONG $0x0303840f; WORD $0x0000 // je LBB36_11, $771(%rip) + LONG $0x0019870f; WORD $0x0000 // ja LBB31_5, $25(%rip) + WORD $0x8944; BYTE $0xf9 // movl %r15d, %ecx + WORD $0xd9f7 // negl %ecx + LONG $0xffc2c748; WORD $0xffff; BYTE $0xff // movq $-1, %rdx + WORD $0xd348; BYTE $0xe2 // shlq %cl, %rdx + WORD $0xd2f7 // notl %edx + WORD $0xf285 // testl %esi, %edx + LONG $0x03fc840f; WORD $0x0000 // je LBB31_32, $1020(%rip) -LBB36_6: - WORD $0x8945; BYTE $0xfe // movl %r15d, %r14d +LBB31_5: + WORD $0x8941; BYTE $0xf6 // movl %esi, %r14d LONG $0x01e68341 // andl $1, %r14d WORD $0xc085 // testl %eax, %eax WORD $0x940f; BYTE $0xc0 // sete %al - WORD $0xfa83; BYTE $0x02 // cmpl $2, %edx - WORD $0x930f; BYTE $0xc1 // setae %cl + WORD $0xfb83; BYTE $0x01 // cmpl $1, %ebx + WORD $0x970f; BYTE $0xc1 // seta %cl WORD $0xc120 // andb %al, %cl WORD $0xb60f; BYTE $0xc9 // movzbl %cl, %ecx - WORD $0x8945; BYTE $0xfa // movl %r15d, %r10d + WORD $0x8941; BYTE $0xf2 // movl %esi, %r10d LONG $0x02e2c141 // shll $2, %r10d - LONG $0xb9048d42 // leal (%rcx,%r15,4), %eax - WORD $0xc083; BYTE $0xfe // addl $-2, %eax - LONG $0x13d06941; WORD $0x1344; BYTE $0x00 // imull $1262611, %r8d, %edx - LONG $0x019a8d44; WORD $0xf801; BYTE $0xff // leal $-524031(%rdx), %r11d + LONG $0xfeb1448d // leal $-2(%rcx,%rsi,4), %eax + LONG $0x13d76941; WORD $0x1344; BYTE $0x00 // imull $1262611, %r15d, %edx + WORD $0xdb31 // xorl %ebx, %ebx WORD $0xc984 // testb %cl, %cl - LONG $0xda440f44 // cmovel %edx, %r11d + LONG $0x0101bb41; WORD $0xfff8 // movl $-524031, %r11d + LONG $0xdb440f44 // cmovel %ebx, %r11d + WORD $0x0141; BYTE $0xd3 // addl %edx, %r11d LONG $0x16fbc141 // sarl $22, %r11d LONG $0xb1cb6941; WORD $0xe56c; BYTE $0xff // imull $-1741647, %r11d, %ecx WORD $0xe9c1; BYTE $0x13 // shrl $19, %ecx - WORD $0x0144; BYTE $0xc1 // addl %r8d, %ecx + WORD $0x0144; BYTE $0xf9 // addl %r15d, %ecx LONG $0x00001fba; BYTE $0x00 // movl $31, %edx WORD $0x2944; BYTE $0xda // subl %r11d, %edx - LONG $0x65358d48; WORD $0x00b7; BYTE $0x00 // leaq $46949(%rip), %rsi /* _pow10_ceil_sig_f32.g(%rip) */ + LONG $0x691d8d48; WORD $0x00b4; BYTE $0x00 // leaq $46185(%rip), %rbx /* _pow10_ceil_sig_f32.g(%rip) */ WORD $0xc1fe // incb %cl WORD $0xe0d3 // shll %cl, %eax - LONG $0xd6248b4c // movq (%rsi,%rdx,8), %r12 + LONG $0xd3248b4c // movq (%rbx,%rdx,8), %r12 WORD $0xf749; BYTE $0xe4 // mulq %r12 - QUAD $0x00000002bd048d46 // leal $2(,%r15,4), %r8d - WORD $0xf631 // xorl %esi, %esi - LONG $0x21e8c148 // shrq $33, %rax - LONG $0xc6950f40 // setne %sil - WORD $0xd609 // orl %edx, %esi + LONG $0x20e8c148 // shrq $32, %rax + WORD $0xdb31 // xorl %ebx, %ebx + WORD $0xf883; BYTE $0x01 // cmpl $1, %eax + WORD $0x970f; BYTE $0xc3 // seta %bl WORD $0xd341; BYTE $0xe2 // shll %cl, %r10d + WORD $0xd309 // orl %edx, %ebx WORD $0x894c; BYTE $0xd0 // movq %r10, %rax WORD $0xf749; BYTE $0xe4 // mulq %r12 WORD $0x8949; BYTE $0xd2 // movq %rdx, %r10 + LONG $0x20e8c148 // shrq $32, %rax WORD $0x3145; BYTE $0xff // xorl %r15d, %r15d - LONG $0x21e8c148 // shrq $33, %rax - LONG $0xc7950f41 // setne %r15b + WORD $0xf883; BYTE $0x01 // cmpl $1, %eax + LONG $0xc7970f41 // seta %r15b + LONG $0x02b5048d; WORD $0x0000; BYTE $0x00 // leal $2(,%rsi,4), %eax + WORD $0xe0d3 // shll %cl, %eax WORD $0x0945; BYTE $0xd7 // orl %r10d, %r15d - WORD $0xd341; BYTE $0xe0 // shll %cl, %r8d - WORD $0x894c; BYTE $0xc0 // movq %r8, %rax WORD $0xf749; BYTE $0xe4 // mulq %r12 + LONG $0x20e8c148 // shrq $32, %rax WORD $0xc931 // xorl %ecx, %ecx - LONG $0x21e8c148 // shrq $33, %rax - WORD $0x950f; BYTE $0xc1 // setne %cl + WORD $0xf883; BYTE $0x01 // cmpl $1, %eax + WORD $0x970f; BYTE $0xc1 // seta %cl WORD $0xd109 // orl %edx, %ecx - WORD $0x0144; BYTE $0xf6 // addl %r14d, %esi + WORD $0x0144; BYTE $0xf3 // addl %r14d, %ebx WORD $0x2944; BYTE $0xf1 // subl %r14d, %ecx LONG $0x28ff8341 // cmpl $40, %r15d - LONG $0x0042820f; WORD $0x0000 // jb LBB36_26, $66(%rip) + LONG $0x003d820f; WORD $0x0000 // jb LBB31_7, $61(%rip) WORD $0x8944; BYTE $0xd0 // movl %r10d, %eax - LONG $0xcccccdba; BYTE $0xcc // movl $3435973837, %edx - LONG $0xd0af0f48 // imulq %rax, %rdx - LONG $0x25eac148 // shrq $37, %rdx - WORD $0x8941; BYTE $0xf0 // movl %esi, %r8d - QUAD $0x00000000d51c8d48 // leaq (,%rdx,8), %rbx - LONG $0x9b048d48 // leaq (%rbx,%rbx,4), %rax - WORD $0x394c; BYTE $0xc0 // cmpq %r8, %rax + LONG $0xcccdbd41; WORD $0xcccc // movl $3435973837, %r13d + LONG $0xe8af0f4c // imulq %rax, %r13 + LONG $0x25edc149 // shrq $37, %r13 + WORD $0x8941; BYTE $0xde // movl %ebx, %r14d + QUAD $0x00000000ed348d4a // leaq (,%r13,8), %rsi + LONG $0xb6048d48 // leaq (%rsi,%rsi,4), %rax + WORD $0x394c; BYTE $0xf0 // cmpq %r14, %rax LONG $0xc6920f41 // setb %r14b - LONG $0x9b048d4c // leaq (%rbx,%rbx,4), %r8 - LONG $0x28c08349 // addq $40, %r8 - WORD $0xcb89 // movl %ecx, %ebx - WORD $0xc031 // xorl %eax, %eax - WORD $0x3949; BYTE $0xd8 // cmpq %rbx, %r8 - LONG $0xc0960f41 // setbe %r8b - WORD $0x3845; BYTE $0xc6 // cmpb %r8b, %r14b - LONG $0x00b3840f; WORD $0x0000 // je LBB36_8, $179(%rip) - -LBB36_26: - WORD $0x8945; BYTE $0xd0 // movl %r10d, %r8d - LONG $0x02e8c141 // shrl $2, %r8d - WORD $0x8944; BYTE $0xd2 // movl %r10d, %edx - WORD $0xe283; BYTE $0xfc // andl $-4, %edx - WORD $0xd639 // cmpl %edx, %esi - LONG $0xc6970f40 // seta %sil - WORD $0x428d; BYTE $0x04 // leal $4(%rdx), %eax - WORD $0xc839 // cmpl %ecx, %eax + LONG $0xb6648d4c; BYTE $0x28 // leaq $40(%rsi,%rsi,4), %r12 + WORD $0xce89 // movl %ecx, %esi + WORD $0x3949; BYTE $0xf4 // cmpq %rsi, %r12 + WORD $0x960f; BYTE $0xc0 // setbe %al + WORD $0x3044; BYTE $0xf0 // xorb %r14b, %al + LONG $0x01e9840f; WORD $0x0000 // je LBB31_16, $489(%rip) + +LBB31_7: + WORD $0x894c; BYTE $0xd0 // movq %r10, %rax + LONG $0x02e8c148 // shrq $2, %rax + WORD $0x8944; BYTE $0xd6 // movl %r10d, %esi + WORD $0xe683; BYTE $0xfc // andl $-4, %esi + WORD $0xf339 // cmpl %esi, %ebx + LONG $0xc6970f41 // seta %r14b + WORD $0x568d; BYTE $0x04 // leal $4(%rsi), %edx + WORD $0xca39 // cmpl %ecx, %edx WORD $0x960f; BYTE $0xc3 // setbe %bl - WORD $0x3040; BYTE $0xf3 // xorb %sil, %bl - LONG $0x0044840f; WORD $0x0000 // je LBB36_27, $68(%rip) - WORD $0xca83; BYTE $0x02 // orl $2, %edx - LONG $0x000001b8; BYTE $0x00 // movl $1, %eax - WORD $0x3941; BYTE $0xd7 // cmpl %edx, %r15d - LONG $0x000e870f; WORD $0x0000 // ja LBB36_30, $14(%rip) - WORD $0x940f; BYTE $0xc0 // sete %al + WORD $0x3044; BYTE $0xf3 // xorb %r14b, %bl + LONG $0x0074840f; WORD $0x0000 // je LBB31_12, $116(%rip) + WORD $0xce83; BYTE $0x02 // orl $2, %esi + LONG $0x0001bd41; WORD $0x0000 // movl $1, %r13d + WORD $0x3941; BYTE $0xf7 // cmpl %esi, %r15d + LONG $0x000e870f; WORD $0x0000 // ja LBB31_10, $14(%rip) + WORD $0x940f; BYTE $0xc1 // sete %cl LONG $0x02eac041 // shrb $2, %r10b - WORD $0x2041; BYTE $0xc2 // andb %al, %r10b - LONG $0xc2b60f41 // movzbl %r10b, %eax - -LBB36_30: - WORD $0x0144; BYTE $0xc0 // addl %r8d, %eax - LONG $0x0186a03d; BYTE $0x00 // cmpl $100000, %eax - LONG $0x002b830f; WORD $0x0000 // jae LBB36_32, $43(%rip) - LONG $0x000070e9; BYTE $0x00 // jmp LBB36_35, $112(%rip) - -LBB36_3: - LONG $0x3001c641 // movb $48, (%r9) - WORD $0x2941; BYTE $0xf9 // subl %edi, %r9d - WORD $0xff41; BYTE $0xc1 // incl %r9d - WORD $0x8944; BYTE $0xc8 // movl %r9d, %eax - LONG $0x0006b3e9; BYTE $0x00 // jmp LBB36_147, $1715(%rip) - -LBB36_27: - WORD $0xc139 // cmpl %eax, %ecx - LONG $0xffd88341 // sbbl $-1, %r8d - WORD $0x8944; BYTE $0xc0 // movl %r8d, %eax - LONG $0x0186a03d; BYTE $0x00 // cmpl $100000, %eax - LONG $0x004a820f; WORD $0x0000 // jb LBB36_35, $74(%rip) - -LBB36_32: - LONG $0x0006be41; WORD $0x0000 // movl $6, %r14d - LONG $0x0f42403d; BYTE $0x00 // cmpl $1000000, %eax - LONG $0x0078820f; WORD $0x0000 // jb LBB36_39, $120(%rip) - LONG $0x0007be41; WORD $0x0000 // movl $7, %r14d - LONG $0x9896803d; BYTE $0x00 // cmpl $10000000, %eax - LONG $0x0067820f; WORD $0x0000 // jb LBB36_39, $103(%rip) - WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d - LONG $0xf5e1003d; BYTE $0x05 // cmpl $100000000, %eax - LONG $0xc6920f41 // setb %r14b - LONG $0x09f68341 // xorl $9, %r14d - LONG $0x000052e9; BYTE $0x00 // jmp LBB36_39, $82(%rip) + WORD $0x2041; BYTE $0xca // andb %cl, %r10b + LONG $0xeab60f45 // movzbl %r10b, %r13d + +LBB31_10: + WORD $0x0141; BYTE $0xc5 // addl %eax, %r13d + LONG $0xa0fd8141; WORD $0x0186; BYTE $0x00 // cmpl $100000, %r13d + LONG $0x0059820f; WORD $0x0000 // jb LBB31_17, $89(%rip) + +LBB31_13: + LONG $0x000006be; BYTE $0x00 // movl $6, %esi + LONG $0x40fd8141; WORD $0x0f42; BYTE $0x00 // cmpl $1000000, %r13d + LONG $0x0086820f; WORD $0x0000 // jb LBB31_22, $134(%rip) + LONG $0x000007be; BYTE $0x00 // movl $7, %esi + LONG $0x80fd8141; WORD $0x9896; BYTE $0x00 // cmpl $10000000, %r13d + LONG $0x0074820f; WORD $0x0000 // jb LBB31_22, $116(%rip) + LONG $0x00fd8141; WORD $0xf5e1; BYTE $0x05 // cmpl $100000000, %r13d + LONG $0x000009be; BYTE $0x00 // movl $9, %esi + LONG $0x000060e9; BYTE $0x00 // jmp LBB31_21, $96(%rip) + +LBB31_11: + LONG $0x3000c641 // movb $48, (%r8) + WORD $0x2941; BYTE $0xf8 // subl %edi, %r8d + WORD $0xff41; BYTE $0xc0 // incl %r8d + LONG $0x000aa9e9; BYTE $0x00 // jmp LBB31_137, $2729(%rip) + +LBB31_12: + WORD $0xd139 // cmpl %edx, %ecx + WORD $0xd883; BYTE $0xff // sbbl $-1, %eax + WORD $0x8941; BYTE $0xc5 // movl %eax, %r13d + LONG $0xa0fd8141; WORD $0x0186; BYTE $0x00 // cmpl $100000, %r13d + LONG $0xffa7830f; WORD $0xffff // jae LBB31_13, $-89(%rip) + +LBB31_17: + LONG $0x000001be; BYTE $0x00 // movl $1, %esi + LONG $0x0afd8341 // cmpl $10, %r13d + LONG $0x0030820f; WORD $0x0000 // jb LBB31_22, $48(%rip) + LONG $0x000002be; BYTE $0x00 // movl $2, %esi + LONG $0x64fd8341 // cmpl $100, %r13d + LONG $0x0021820f; WORD $0x0000 // jb LBB31_22, $33(%rip) + LONG $0x000003be; BYTE $0x00 // movl $3, %esi + LONG $0xe8fd8141; WORD $0x0003; BYTE $0x00 // cmpl $1000, %r13d + LONG $0x000f820f; WORD $0x0000 // jb LBB31_22, $15(%rip) + LONG $0x10fd8141; WORD $0x0027; BYTE $0x00 // cmpl $10000, %r13d + LONG $0x000005be; BYTE $0x00 // movl $5, %esi + +LBB31_21: + WORD $0xde83; BYTE $0x00 // sbbl $0, %esi + +LBB31_22: + LONG $0x1e148d46 // leal (%rsi,%r11), %r10d + LONG $0x1e448d42; BYTE $0x05 // leal $5(%rsi,%r11), %eax + WORD $0xf883; BYTE $0x1b // cmpl $27, %eax + LONG $0x0075820f; WORD $0x0000 // jb LBB31_26, $117(%rip) + WORD $0xf089 // movl %esi, %eax + LONG $0x00748d4d; BYTE $0x01 // leaq $1(%r8,%rax), %r14 + LONG $0x10fd8141; WORD $0x0027; BYTE $0x00 // cmpl $10000, %r13d + LONG $0x00f3820f; WORD $0x0000 // jb LBB31_30, $243(%rip) + WORD $0x8944; BYTE $0xe8 // movl %r13d, %eax + LONG $0xb71759bb; BYTE $0xd1 // movl $3518437209, %ebx + LONG $0xd8af0f48 // imulq %rax, %rbx + LONG $0x2debc148 // shrq $45, %rbx + LONG $0xd8f0c369; WORD $0xffff // imull $-10000, %ebx, %eax + WORD $0x0144; BYTE $0xe8 // addl %r13d, %eax + LONG $0x047b840f; WORD $0x0000 // je LBB31_62, $1147(%rip) + WORD $0xc189 // movl %eax, %ecx + LONG $0x1fc96948; WORD $0xeb85; BYTE $0x51 // imulq $1374389535, %rcx, %rcx + LONG $0x25e9c148 // shrq $37, %rcx + WORD $0xd16b; BYTE $0x64 // imull $100, %ecx, %edx + WORD $0xd029 // subl %edx, %eax + LONG $0x02158d48; WORD $0x003f; BYTE $0x00 // leaq $16130(%rip), %rdx /* _Digits(%rip) */ + LONG $0x4204b70f // movzwl (%rdx,%rax,2), %eax + LONG $0x46894166; BYTE $0xfe // movw %ax, $-2(%r14) + LONG $0x4a04b70f // movzwl (%rdx,%rcx,2), %eax + LONG $0x46894166; BYTE $0xfc // movw %ax, $-4(%r14) + WORD $0x3145; BYTE $0xc9 // xorl %r9d, %r9d + LONG $0xfc4e8d49 // leaq $-4(%r14), %rcx + WORD $0xfb83; BYTE $0x64 // cmpl $100, %ebx + LONG $0x00ab830f; WORD $0x0000 // jae LBB31_64, $171(%rip) -LBB36_8: - WORD $0x8844; BYTE $0xc0 // movb %r8b, %al - WORD $0xd001 // addl %edx, %eax - WORD $0xff41; BYTE $0xc3 // incl %r11d - LONG $0x0186a03d; BYTE $0x00 // cmpl $100000, %eax - LONG $0xffb6830f; WORD $0xffff // jae LBB36_32, $-74(%rip) +LBB31_31: + WORD $0xda89 // movl %ebx, %edx + LONG $0x0000e8e9; BYTE $0x00 // jmp LBB31_66, $232(%rip) -LBB36_35: - LONG $0x0001be41; WORD $0x0000 // movl $1, %r14d - WORD $0xf883; BYTE $0x0a // cmpl $10, %eax - LONG $0x0030820f; WORD $0x0000 // jb LBB36_39, $48(%rip) - LONG $0x0002be41; WORD $0x0000 // movl $2, %r14d - WORD $0xf883; BYTE $0x64 // cmpl $100, %eax - LONG $0x0021820f; WORD $0x0000 // jb LBB36_39, $33(%rip) - LONG $0x0003be41; WORD $0x0000 // movl $3, %r14d - LONG $0x0003e83d; BYTE $0x00 // cmpl $1000, %eax - LONG $0x0010820f; WORD $0x0000 // jb LBB36_39, $16(%rip) - WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d - LONG $0x0027103d; BYTE $0x00 // cmpl $10000, %eax - LONG $0xc6920f41 // setb %r14b - LONG $0x05f68341 // xorl $5, %r14d - -LBB36_39: - LONG $0x1e148d47 // leal (%r14,%r11), %r10d - LONG $0x1e0c8d43 // leal (%r14,%r11), %ecx - WORD $0xc183; BYTE $0xea // addl $-22, %ecx - WORD $0xf983; BYTE $0xe4 // cmpl $-28, %ecx - LONG $0x0069870f; WORD $0x0000 // ja LBB36_64, $105(%rip) - WORD $0x8945; BYTE $0xf6 // movl %r14d, %r14d - LONG $0x31148d4b // leaq (%r9,%r14), %rdx - WORD $0xff48; BYTE $0xc2 // incq %rdx - LONG $0x0027103d; BYTE $0x00 // cmpl $10000, %eax - LONG $0x00c8820f; WORD $0x0000 // jb LBB36_41, $200(%rip) - WORD $0xc389 // movl %eax, %ebx +LBB31_26: + WORD $0x8941; BYTE $0xf4 // movl %esi, %r12d + WORD $0x8545; BYTE $0xdb // testl %r11d, %r11d + LONG $0x021d880f; WORD $0x0000 // js LBB31_38, $541(%rip) + LONG $0x20348d4b // leaq (%r8,%r12), %rsi + LONG $0x10fd8141; WORD $0x0027; BYTE $0x00 // cmpl $10000, %r13d + LONG $0x028d820f; WORD $0x0000 // jb LBB31_43, $653(%rip) + WORD $0x8944; BYTE $0xe8 // movl %r13d, %eax LONG $0xb71759b9; BYTE $0xd1 // movl $3518437209, %ecx - LONG $0xcbaf0f48 // imulq %rbx, %rcx + LONG $0xc8af0f48 // imulq %rax, %rcx LONG $0x2de9c148 // shrq $45, %rcx - LONG $0xf0c16944; WORD $0xffd8; BYTE $0xff // imull $-10000, %ecx, %r8d - WORD $0x0141; BYTE $0xc0 // addl %eax, %r8d - LONG $0x02f8840f; WORD $0x0000 // je LBB36_43, $760(%rip) - WORD $0x8944; BYTE $0xc0 // movl %r8d, %eax - LONG $0x1fc06948; WORD $0xeb85; BYTE $0x51 // imulq $1374389535, %rax, %rax - LONG $0x25e8c148 // shrq $37, %rax - WORD $0xd86b; BYTE $0x64 // imull $100, %eax, %ebx - WORD $0x2941; BYTE $0xd8 // subl %ebx, %r8d - LONG $0xde1d8d4c; WORD $0x0041; BYTE $0x00 // leaq $16862(%rip), %r11 /* _Digits(%rip) */ - LONG $0x1cb70f43; BYTE $0x43 // movzwl (%r11,%r8,2), %ebx - LONG $0xfe5a8966 // movw %bx, $-2(%rdx) - LONG $0x04b70f41; BYTE $0x43 // movzwl (%r11,%rax,2), %eax - LONG $0xfc428966 // movw %ax, $-4(%rdx) - WORD $0x3145; BYTE $0xc0 // xorl %r8d, %r8d - LONG $0x0002c9e9; BYTE $0x00 // jmp LBB36_45, $713(%rip) - -LBB36_64: - WORD $0x8945; BYTE $0xf4 // movl %r14d, %r12d - WORD $0x8545; BYTE $0xdb // testl %r11d, %r11d - LONG $0x0109880f; WORD $0x0000 // js LBB36_65, $265(%rip) - LONG $0x213c8d4f // leaq (%r9,%r12), %r15 - LONG $0x0027103d; BYTE $0x00 // cmpl $10000, %eax - LONG $0x0136820f; WORD $0x0000 // jb LBB36_118, $310(%rip) - WORD $0xc189 // movl %eax, %ecx - LONG $0xb71759ba; BYTE $0xd1 // movl $3518437209, %edx - LONG $0xd1af0f48 // imulq %rcx, %rdx - LONG $0x2deac148 // shrq $45, %rdx - LONG $0xd8f0ca69; WORD $0xffff // imull $-10000, %edx, %ecx - WORD $0xc101 // addl %eax, %ecx - LONG $0x1fc16948; WORD $0xeb85; BYTE $0x51 // imulq $1374389535, %rcx, %rax - LONG $0x25e8c148 // shrq $37, %rax - WORD $0xd86b; BYTE $0x64 // imull $100, %eax, %ebx - WORD $0xd929 // subl %ebx, %ecx - LONG $0x7b1d8d48; WORD $0x0041; BYTE $0x00 // leaq $16763(%rip), %rbx /* _Digits(%rip) */ - LONG $0x4b0cb70f // movzwl (%rbx,%rcx,2), %ecx - LONG $0x4f894166; BYTE $0xfe // movw %cx, $-2(%r15) - LONG $0xfc4f8d49 // leaq $-4(%r15), %rcx - LONG $0x4304b70f // movzwl (%rbx,%rax,2), %eax - LONG $0x47894166; BYTE $0xfc // movw %ax, $-4(%r15) - WORD $0xd089 // movl %edx, %eax - WORD $0x8945; BYTE $0xd3 // movl %r10d, %r11d - WORD $0xf883; BYTE $0x64 // cmpl $100, %eax - LONG $0x00f3830f; WORD $0x0000 // jae LBB36_122, $243(%rip) - -LBB36_121: - WORD $0xc289 // movl %eax, %edx - LONG $0x00012ee9; BYTE $0x00 // jmp LBB36_124, $302(%rip) - -LBB36_41: - WORD $0x3145; BYTE $0xc0 // xorl %r8d, %r8d - WORD $0xc189 // movl %eax, %ecx - WORD $0xf983; BYTE $0x64 // cmpl $100, %ecx - LONG $0x0254830f; WORD $0x0000 // jae LBB36_48, $596(%rip) - -LBB36_47: - WORD $0xc889 // movl %ecx, %eax - LONG $0x00028ae9; BYTE $0x00 // jmp LBB36_50, $650(%rip) - -LBB36_11: - WORD $0xd341; BYTE $0xef // shrl %cl, %r15d - LONG $0xa0ff8141; WORD $0x0186; BYTE $0x00 // cmpl $100000, %r15d - LONG $0x017d820f; WORD $0x0000 // jb LBB36_14, $381(%rip) - LONG $0x80ff8141; WORD $0x9896; BYTE $0x00 // cmpl $10000000, %r15d - LONG $0x000008b8; BYTE $0x00 // movl $8, %eax - LONG $0x00d88348 // sbbq $0, %rax - LONG $0x40ff8141; WORD $0x0f42; BYTE $0x00 // cmpl $1000000, %r15d - LONG $0x000006b9; BYTE $0x00 // movl $6, %ecx - LONG $0xc8430f48 // cmovaeq %rax, %rcx - WORD $0x014c; BYTE $0xc9 // addq %r9, %rcx - -LBB36_13: - WORD $0x8944; BYTE $0xf8 // movl %r15d, %eax - LONG $0xb71759ba; BYTE $0xd1 // movl $3518437209, %edx - LONG $0xd0af0f48 // imulq %rax, %rdx - LONG $0x2deac148 // shrq $45, %rdx - LONG $0xd8f0c269; WORD $0xffff // imull $-10000, %edx, %eax - WORD $0x0144; BYTE $0xf8 // addl %r15d, %eax - LONG $0x1ff06948; WORD $0xeb85; BYTE $0x51 // imulq $1374389535, %rax, %rsi - LONG $0x25eec148 // shrq $37, %rsi - WORD $0xde6b; BYTE $0x64 // imull $100, %esi, %ebx + LONG $0xd8f0c169; WORD $0xffff // imull $-10000, %ecx, %eax + WORD $0x0144; BYTE $0xe8 // addl %r13d, %eax + LONG $0x1fd06948; WORD $0xeb85; BYTE $0x51 // imulq $1374389535, %rax, %rdx + LONG $0x25eac148 // shrq $37, %rdx + WORD $0xda6b; BYTE $0x64 // imull $100, %edx, %ebx WORD $0xd829 // subl %ebx, %eax - LONG $0xd81d8d48; WORD $0x0040; BYTE $0x00 // leaq $16600(%rip), %rbx /* _Digits(%rip) */ + LONG $0x8c1d8d48; WORD $0x003e; BYTE $0x00 // leaq $16012(%rip), %rbx /* _Digits(%rip) */ LONG $0x4304b70f // movzwl (%rbx,%rax,2), %eax - LONG $0xfe418966 // movw %ax, $-2(%rcx) - LONG $0x7304b70f // movzwl (%rbx,%rsi,2), %eax - LONG $0xfc418966 // movw %ax, $-4(%rcx) - WORD $0x8948; BYTE $0xc8 // movq %rcx, %rax - LONG $0xfcc18348 // addq $-4, %rcx - WORD $0x8941; BYTE $0xd7 // movl %edx, %r15d - LONG $0x64ff8341 // cmpl $100, %r15d - LONG $0x0146830f; WORD $0x0000 // jae LBB36_21, $326(%rip) - LONG $0x000181e9; BYTE $0x00 // jmp LBB36_23, $385(%rip) - -LBB36_65: - WORD $0x8545; BYTE $0xd2 // testl %r10d, %r10d - LONG $0x05458f0f; WORD $0x0000 // jg LBB36_79, $1349(%rip) - LONG $0x01c74166; WORD $0x2e30 // movw $11824, (%r9) - LONG $0x02c18349 // addq $2, %r9 - WORD $0x8545; BYTE $0xd2 // testl %r10d, %r10d - LONG $0x0532890f; WORD $0x0000 // jns LBB36_79, $1330(%rip) - WORD $0x894c; BYTE $0xe3 // movq %r12, %rbx - WORD $0x8945; BYTE $0xf4 // movl %r14d, %r12d - WORD $0xf741; BYTE $0xd4 // notl %r12d - WORD $0x2945; BYTE $0xdc // subl %r11d, %r12d - WORD $0xc931 // xorl %ecx, %ecx - LONG $0x1ffc8341 // cmpl $31, %r12d - LONG $0x0402830f; WORD $0x0000 // jae LBB36_69, $1026(%rip) - WORD $0x8949; BYTE $0xdc // movq %rbx, %r12 - LONG $0x0004f2e9; BYTE $0x00 // jmp LBB36_77, $1266(%rip) - -LBB36_118: - WORD $0x894c; BYTE $0xf9 // movq %r15, %rcx - WORD $0x8945; BYTE $0xd3 // movl %r10d, %r11d - WORD $0xf883; BYTE $0x64 // cmpl $100, %eax - LONG $0xff0d820f; WORD $0xffff // jb LBB36_121, $-243(%rip) + LONG $0xfe468966 // movw %ax, $-2(%rsi) + LONG $0xfc468d48 // leaq $-4(%rsi), %rax + LONG $0x5314b70f // movzwl (%rbx,%rdx,2), %edx + LONG $0xfc568966 // movw %dx, $-4(%rsi) + WORD $0x8941; BYTE $0xcd // movl %ecx, %r13d + LONG $0x64fd8341 // cmpl $100, %r13d + LONG $0x0249830f; WORD $0x0000 // jae LBB31_44, $585(%rip) + +LBB31_29: + WORD $0x8944; BYTE $0xe9 // movl %r13d, %ecx + LONG $0x000286e9; BYTE $0x00 // jmp LBB31_46, $646(%rip) + +LBB31_16: + WORD $0x394c; BYTE $0xe6 // cmpq %r12, %rsi + LONG $0xffdd8341 // sbbl $-1, %r13d + WORD $0xff41; BYTE $0xc3 // incl %r11d + LONG $0xa0fd8141; WORD $0x0186; BYTE $0x00 // cmpl $100000, %r13d + LONG $0xfe54830f; WORD $0xffff // jae LBB31_13, $-428(%rip) + LONG $0xfffea8e9; BYTE $0xff // jmp LBB31_17, $-344(%rip) + +LBB31_30: + WORD $0x3145; BYTE $0xc9 // xorl %r9d, %r9d + WORD $0x894c; BYTE $0xf1 // movq %r14, %rcx + WORD $0x8944; BYTE $0xeb // movl %r13d, %ebx + WORD $0xfb83; BYTE $0x64 // cmpl $100, %ebx + LONG $0xff55820f; WORD $0xffff // jb LBB31_31, $-171(%rip) -LBB36_122: - WORD $0xff48; BYTE $0xc9 // decq %rcx - LONG $0x5a058d4c; WORD $0x0040; BYTE $0x00 // leaq $16474(%rip), %r8 /* _Digits(%rip) */ - QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90 +LBB31_64: + WORD $0xff48; BYTE $0xc9 // decq %rcx + LONG $0x2b1d8d4c; WORD $0x003e; BYTE $0x00 // leaq $15915(%rip), %r11 /* _Digits(%rip) */ + QUAD $0x9090909090909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 -LBB36_123: - WORD $0xc289 // movl %eax, %edx +LBB31_65: + WORD $0xda89 // movl %ebx, %edx LONG $0x1fd26948; WORD $0xeb85; BYTE $0x51 // imulq $1374389535, %rdx, %rdx LONG $0x25eac148 // shrq $37, %rdx - WORD $0xda6b; BYTE $0x64 // imull $100, %edx, %ebx - WORD $0xc689 // movl %eax, %esi - WORD $0xde29 // subl %ebx, %esi - LONG $0x34b70f41; BYTE $0x70 // movzwl (%r8,%rsi,2), %esi - LONG $0xff718966 // movw %si, $-1(%rcx) + WORD $0xc26b; BYTE $0x64 // imull $100, %edx, %eax + WORD $0xde89 // movl %ebx, %esi + WORD $0xc629 // subl %eax, %esi + LONG $0x04b70f41; BYTE $0x73 // movzwl (%r11,%rsi,2), %eax + LONG $0xff418966 // movw %ax, $-1(%rcx) LONG $0xfec18348 // addq $-2, %rcx - LONG $0x00270f3d; BYTE $0x00 // cmpl $9999, %eax - WORD $0xd089 // movl %edx, %eax - LONG $0xffd2870f; WORD $0xffff // ja LBB36_123, $-46(%rip) + LONG $0x270ffb81; WORD $0x0000 // cmpl $9999, %ebx + WORD $0xd389 // movl %edx, %ebx + LONG $0xffd1870f; WORD $0xffff // ja LBB31_65, $-47(%rip) -LBB36_124: +LBB31_66: + LONG $0x01708d49 // leaq $1(%r8), %rsi WORD $0xfa83; BYTE $0x0a // cmpl $10, %edx - LONG $0x0022820f; WORD $0x0000 // jb LBB36_126, $34(%rip) + LONG $0x001d820f; WORD $0x0000 // jb LBB31_68, $29(%rip) WORD $0xd089 // movl %edx, %eax - LONG $0x100d8d48; WORD $0x0040; BYTE $0x00 // leaq $16400(%rip), %rcx /* _Digits(%rip) */ - LONG $0x4104b70f // movzwl (%rcx,%rax,2), %eax - LONG $0x01894166 // movw %ax, (%r9) - WORD $0x014d; BYTE $0xd9 // addq %r11, %r9 - WORD $0x3945; BYTE $0xd6 // cmpl %r10d, %r14d - LONG $0x0017820f; WORD $0x0000 // jb LBB36_128, $23(%rip) - LONG $0x0003c7e9; BYTE $0x00 // jmp LBB36_145, $967(%rip) - -LBB36_126: - WORD $0xc280; BYTE $0x30 // addb $48, %dl - WORD $0x8841; BYTE $0x11 // movb %dl, (%r9) - WORD $0x014d; BYTE $0xd9 // addq %r11, %r9 - WORD $0x3945; BYTE $0xd6 // cmpl %r10d, %r14d - LONG $0x03b5830f; WORD $0x0000 // jae LBB36_145, $949(%rip) - -LBB36_128: - LONG $0x2f048d4a // leaq (%rdi,%r13), %rax - LONG $0x040c8d49 // leaq (%r12,%rax), %rcx - WORD $0xff48; BYTE $0xc1 // incq %rcx - WORD $0x0149; BYTE $0xc3 // addq %rax, %r11 - WORD $0x394c; BYTE $0xd9 // cmpq %r11, %rcx - LONG $0xd9470f4c // cmovaq %rcx, %r11 - WORD $0x014c; BYTE $0xe0 // addq %r12, %rax - WORD $0x2949; BYTE $0xc3 // subq %rax, %r11 - LONG $0x08fb8349 // cmpq $8, %r11 - LONG $0x0380820f; WORD $0x0000 // jb LBB36_144, $896(%rip) - LONG $0x20fb8349 // cmpq $32, %r11 - LONG $0x01e5830f; WORD $0x0000 // jae LBB36_134, $485(%rip) - WORD $0x3145; BYTE $0xd2 // xorl %r10d, %r10d - LONG $0x0002c9e9; BYTE $0x00 // jmp LBB36_131, $713(%rip) - -LBB36_14: - LONG $0x000001b8; BYTE $0x00 // movl $1, %eax - LONG $0x0aff8341 // cmpl $10, %r15d - LONG $0x0021820f; WORD $0x0000 // jb LBB36_17, $33(%rip) - LONG $0x000002b8; BYTE $0x00 // movl $2, %eax - LONG $0x64ff8341 // cmpl $100, %r15d - LONG $0x0012820f; WORD $0x0000 // jb LBB36_17, $18(%rip) - LONG $0x000003b8; BYTE $0x00 // movl $3, %eax - LONG $0xe7ff8141; WORD $0x0003; BYTE $0x00 // cmpl $999, %r15d - LONG $0x02de870f; WORD $0x0000 // ja LBB36_19, $734(%rip) + LONG $0xdb0d8d48; WORD $0x003d; BYTE $0x00 // leaq $15835(%rip), %rcx /* _Digits(%rip) */ + WORD $0x148a; BYTE $0x41 // movb (%rcx,%rax,2), %dl + LONG $0x0141448a // movb $1(%rcx,%rax,2), %al + LONG $0x01508841 // movb %dl, $1(%r8) + LONG $0x02408841 // movb %al, $2(%r8) + LONG $0x000005e9; BYTE $0x00 // jmp LBB31_69, $5(%rip) + +LBB31_68: + WORD $0xc280; BYTE $0x30 // addb $48, %dl + WORD $0x1688 // movb %dl, (%rsi) + +LBB31_69: + WORD $0x294d; BYTE $0xce // subq %r9, %r14 + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 -LBB36_17: - WORD $0x014c; BYTE $0xc8 // addq %r9, %rax +LBB31_70: + LONG $0xff7e8041; BYTE $0x30 // cmpb $48, $-1(%r14) + LONG $0xff768d4d // leaq $-1(%r14), %r14 + LONG $0xfff1840f; WORD $0xffff // je LBB31_70, $-15(%rip) + WORD $0x8841; BYTE $0x10 // movb %dl, (%r8) + LONG $0x01468d49 // leaq $1(%r14), %rax WORD $0x8948; BYTE $0xc1 // movq %rax, %rcx - LONG $0x64ff8341 // cmpl $100, %r15d - LONG $0x0040820f; WORD $0x0000 // jb LBB36_23, $64(%rip) - -LBB36_21: - WORD $0xff48; BYTE $0xc9 // decq %rcx - LONG $0x64058d4c; WORD $0x003f; BYTE $0x00 // leaq $16228(%rip), %r8 /* _Digits(%rip) */ - LONG $0x90909090 // .p2align 4, 0x90 - -LBB36_22: - WORD $0x8944; BYTE $0xfb // movl %r15d, %ebx - WORD $0x8944; BYTE $0xfe // movl %r15d, %esi - LONG $0x1ffe694c; WORD $0xeb85; BYTE $0x51 // imulq $1374389535, %rsi, %r15 - LONG $0x25efc149 // shrq $37, %r15 - LONG $0x64d76b41 // imull $100, %r15d, %edx - WORD $0xde89 // movl %ebx, %esi - WORD $0xd629 // subl %edx, %esi - LONG $0x14b70f41; BYTE $0x70 // movzwl (%r8,%rsi,2), %edx - LONG $0xff518966 // movw %dx, $-1(%rcx) - LONG $0xfec18348 // addq $-2, %rcx - LONG $0x270ffb81; WORD $0x0000 // cmpl $9999, %ebx - LONG $0xffce870f; WORD $0xffff // ja LBB36_22, $-50(%rip) - -LBB36_23: - LONG $0x0aff8341 // cmpl $10, %r15d - LONG $0x0017820f; WORD $0x0000 // jb LBB36_25, $23(%rip) - WORD $0x8944; BYTE $0xf9 // movl %r15d, %ecx - LONG $0x1a158d48; WORD $0x003f; BYTE $0x00 // leaq $16154(%rip), %rdx /* _Digits(%rip) */ - LONG $0x4a0cb70f // movzwl (%rdx,%rcx,2), %ecx - LONG $0x09894166 // movw %cx, (%r9) - LONG $0x0002e0e9; BYTE $0x00 // jmp LBB36_146, $736(%rip) - -LBB36_25: - LONG $0x30c78041 // addb $48, %r15b - WORD $0x8845; BYTE $0x39 // movb %r15b, (%r9) - LONG $0x0002d4e9; BYTE $0x00 // jmp LBB36_146, $724(%rip) - -LBB36_43: - LONG $0x0004b841; WORD $0x0000 // movl $4, %r8d - -LBB36_45: - LONG $0xfcc28348 // addq $-4, %rdx - WORD $0xf983; BYTE $0x64 // cmpl $100, %ecx - LONG $0xfdac820f; WORD $0xffff // jb LBB36_47, $-596(%rip) - -LBB36_48: - WORD $0xff48; BYTE $0xca // decq %rdx - LONG $0xe41d8d4c; WORD $0x003e; BYTE $0x00 // leaq $16100(%rip), %r11 /* _Digits(%rip) */ - LONG $0x90909090 // .p2align 4, 0x90 - -LBB36_49: - WORD $0xc889 // movl %ecx, %eax - LONG $0x1fc06948; WORD $0xeb85; BYTE $0x51 // imulq $1374389535, %rax, %rax - LONG $0x25e8c148 // shrq $37, %rax - WORD $0xd86b; BYTE $0x64 // imull $100, %eax, %ebx - WORD $0xce89 // movl %ecx, %esi - WORD $0xde29 // subl %ebx, %esi - LONG $0x34b70f41; BYTE $0x73 // movzwl (%r11,%rsi,2), %esi - LONG $0xff728966 // movw %si, $-1(%rdx) - LONG $0xfec28348 // addq $-2, %rdx - LONG $0x270ff981; WORD $0x0000 // cmpl $9999, %ecx - WORD $0xc189 // movl %eax, %ecx - LONG $0xffd1870f; WORD $0xffff // ja LBB36_49, $-47(%rip) + WORD $0x2948; BYTE $0xf1 // subq %rsi, %rcx + LONG $0x02f98348 // cmpq $2, %rcx + LONG $0x00068c0f; WORD $0x0000 // jl LBB31_73, $6(%rip) + WORD $0x06c6; BYTE $0x2e // movb $46, (%rsi) + WORD $0x8949; BYTE $0xc6 // movq %rax, %r14 -LBB36_50: - LONG $0x01518d49 // leaq $1(%r9), %rdx - WORD $0xf883; BYTE $0x0a // cmpl $10, %eax - LONG $0x001f820f; WORD $0x0000 // jb LBB36_52, $31(%rip) - WORD $0xc189 // movl %eax, %ecx - LONG $0x9b358d48; WORD $0x003e; BYTE $0x00 // leaq $16027(%rip), %rsi /* _Digits(%rip) */ - LONG $0x4e04b60f // movzbl (%rsi,%rcx,2), %eax - LONG $0x4e4cb60f; BYTE $0x01 // movzbl $1(%rsi,%rcx,2), %ecx - LONG $0x01418841 // movb %al, $1(%r9) - LONG $0x02498841 // movb %cl, $2(%r9) - LONG $0x000004e9; BYTE $0x00 // jmp LBB36_53, $4(%rip) - -LBB36_52: - WORD $0x3004 // addb $48, %al - WORD $0x0288 // movb %al, (%rdx) - -LBB36_53: - WORD $0x294d; BYTE $0xc5 // subq %r8, %r13 - WORD $0x0149; BYTE $0xfd // addq %rdi, %r13 - LONG $0x000001be; BYTE $0x00 // movl $1, %esi - WORD $0x294c; BYTE $0xc6 // subq %r8, %rsi - WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 - -LBB36_54: - WORD $0xff48; BYTE $0xce // decq %rsi - LONG $0x357c8043; WORD $0x3000 // cmpb $48, (%r13,%r14) - LONG $0xff6d8d4d // leaq $-1(%r13), %r13 - LONG $0xffed840f; WORD $0xffff // je LBB36_54, $-19(%rip) - WORD $0x8841; BYTE $0x01 // movb %al, (%r9) - WORD $0x014c; BYTE $0xf6 // addq %r14, %rsi - LONG $0x02fe8348 // cmpq $2, %rsi - LONG $0x00458c0f; WORD $0x0000 // jl LBB36_56, $69(%rip) - LONG $0x2e048d4b // leaq (%r14,%r13), %rax - LONG $0x02c08348 // addq $2, %rax - WORD $0x02c6; BYTE $0x2e // movb $46, (%rdx) - WORD $0x00c6; BYTE $0x65 // movb $101, (%rax) +LBB31_73: + LONG $0x6506c641 // movb $101, (%r14) + LONG $0xff428d41 // leal $-1(%r10), %eax WORD $0x8545; BYTE $0xd2 // testl %r10d, %r10d - LONG $0x00418e0f; WORD $0x0000 // jle LBB36_59, $65(%rip) + LONG $0x01228e0f; WORD $0x0000 // jle LBB31_76, $290(%rip) + LONG $0x0146c641; BYTE $0x2b // movb $43, $1(%r14) + WORD $0xf883; BYTE $0x0a // cmpl $10, %eax + LONG $0x01248c0f; WORD $0x0000 // jl LBB31_77, $292(%rip) -LBB36_60: - WORD $0xff41; BYTE $0xca // decl %r10d - LONG $0x2b0140c6 // movb $43, $1(%rax) - WORD $0x8944; BYTE $0xd1 // movl %r10d, %ecx - WORD $0xf983; BYTE $0x0a // cmpl $10, %ecx - LONG $0x0043820f; WORD $0x0000 // jb LBB36_63, $67(%rip) - -LBB36_62: - WORD $0x6348; BYTE $0xc9 // movslq %ecx, %rcx - LONG $0x19158d48; WORD $0x003e; BYTE $0x00 // leaq $15897(%rip), %rdx /* _Digits(%rip) */ - LONG $0x4a0cb70f // movzwl (%rdx,%rcx,2), %ecx - LONG $0x02488966 // movw %cx, $2(%rax) - LONG $0x04c08348 // addq $4, %rax - LONG $0x0001dbe9; BYTE $0x00 // jmp LBB36_146, $475(%rip) +LBB31_75: + WORD $0x9848 // cltq + LONG $0x5c0d8d48; WORD $0x003d; BYTE $0x00 // leaq $15708(%rip), %rcx /* _Digits(%rip) */ + LONG $0x4104b70f // movzwl (%rcx,%rax,2), %eax + LONG $0x46894166; BYTE $0x02 // movw %ax, $2(%r14) + LONG $0x04c68349 // addq $4, %r14 + WORD $0x894d; BYTE $0xf0 // movq %r14, %r8 + LONG $0x000839e9; BYTE $0x00 // jmp LBB31_136, $2105(%rip) -LBB36_56: - LONG $0x2e048d4b // leaq (%r14,%r13), %rax - WORD $0xff48; BYTE $0xc0 // incq %rax - WORD $0x00c6; BYTE $0x65 // movb $101, (%rax) +LBB31_32: + WORD $0xeed3 // shrl %cl, %esi + LONG $0x86a0fe81; WORD $0x0001 // cmpl $100000, %esi + LONG $0x01ee820f; WORD $0x0000 // jb LBB31_52, $494(%rip) + LONG $0x000006b8; BYTE $0x00 // movl $6, %eax + LONG $0x4240fe81; WORD $0x000f // cmpl $1000000, %esi + LONG $0x0020820f; WORD $0x0000 // jb LBB31_36, $32(%rip) + LONG $0x000007b8; BYTE $0x00 // movl $7, %eax + LONG $0x9680fe81; WORD $0x0098 // cmpl $10000000, %esi + LONG $0x000f820f; WORD $0x0000 // jb LBB31_36, $15(%rip) + LONG $0xe100fe81; WORD $0x05f5 // cmpl $100000000, %esi + LONG $0x000009b8; BYTE $0x00 // movl $9, %eax + LONG $0x00d88348 // sbbq $0, %rax + +LBB31_36: + WORD $0x014c; BYTE $0xc0 // addq %r8, %rax + +LBB31_37: + WORD $0xf189 // movl %esi, %ecx + LONG $0xb71759ba; BYTE $0xd1 // movl $3518437209, %edx + LONG $0xd1af0f48 // imulq %rcx, %rdx + LONG $0x2deac148 // shrq $45, %rdx + LONG $0xd8f0ca69; WORD $0xffff // imull $-10000, %edx, %ecx + WORD $0xf101 // addl %esi, %ecx + LONG $0x1ff16948; WORD $0xeb85; BYTE $0x51 // imulq $1374389535, %rcx, %rsi + LONG $0x25eec148 // shrq $37, %rsi + WORD $0xde6b; BYTE $0x64 // imull $100, %esi, %ebx + WORD $0xd929 // subl %ebx, %ecx + LONG $0xd71d8d48; WORD $0x003c; BYTE $0x00 // leaq $15575(%rip), %rbx /* _Digits(%rip) */ + LONG $0x4b0cb70f // movzwl (%rbx,%rcx,2), %ecx + LONG $0xfe488966 // movw %cx, $-2(%rax) + LONG $0x730cb70f // movzwl (%rbx,%rsi,2), %ecx + LONG $0xfc488966 // movw %cx, $-4(%rax) + WORD $0x8949; BYTE $0xc1 // movq %rax, %r9 + LONG $0xfcc08348 // addq $-4, %rax + WORD $0xd689 // movl %edx, %esi + WORD $0xfe83; BYTE $0x64 // cmpl $100, %esi + LONG $0x01a9830f; WORD $0x0000 // jae LBB31_56, $425(%rip) + LONG $0x0001dfe9; BYTE $0x00 // jmp LBB31_58, $479(%rip) + +LBB31_38: WORD $0x8545; BYTE $0xd2 // testl %r10d, %r10d - LONG $0xffbf8f0f; WORD $0xffff // jg LBB36_60, $-65(%rip) - -LBB36_59: - LONG $0x2d0140c6 // movb $45, $1(%rax) - LONG $0x000001b9; BYTE $0x00 // movl $1, %ecx - WORD $0x2944; BYTE $0xd1 // subl %r10d, %ecx - WORD $0xf983; BYTE $0x0a // cmpl $10, %ecx - LONG $0xffbd830f; WORD $0xffff // jae LBB36_62, $-67(%rip) - -LBB36_63: - WORD $0xc180; BYTE $0x30 // addb $48, %cl - WORD $0x4888; BYTE $0x02 // movb %cl, $2(%rax) - LONG $0x03c08348 // addq $3, %rax - LONG $0x0001a4e9; BYTE $0x00 // jmp LBB36_146, $420(%rip) + LONG $0x04578f0f; WORD $0x0000 // jg LBB31_96, $1111(%rip) + LONG $0x00c74166; WORD $0x2e30 // movw $11824, (%r8) + LONG $0x02c08349 // addq $2, %r8 + WORD $0x8545; BYTE $0xd2 // testl %r10d, %r10d + LONG $0x0444890f; WORD $0x0000 // jns LBB31_96, $1092(%rip) + WORD $0xd6f7 // notl %esi + WORD $0x2944; BYTE $0xde // subl %r11d, %esi + WORD $0x3145; BYTE $0xff // xorl %r15d, %r15d + WORD $0xfe83; BYTE $0x1f // cmpl $31, %esi + LONG $0x0418820f; WORD $0x0000 // jb LBB31_94, $1048(%rip) + WORD $0xff48; BYTE $0xc6 // incq %rsi + WORD $0x8949; BYTE $0xf7 // movq %rsi, %r15 + LONG $0xe0e78349 // andq $-32, %r15 + LONG $0xe0478d49 // leaq $-32(%r15), %rax + WORD $0x8949; BYTE $0xc6 // movq %rax, %r14 + LONG $0x05eec149 // shrq $5, %r14 + WORD $0xff49; BYTE $0xc6 // incq %r14 + WORD $0x8945; BYTE $0xf3 // movl %r14d, %r11d + LONG $0x07e38341 // andl $7, %r11d + LONG $0x00e03d48; WORD $0x0000 // cmpq $224, %rax + LONG $0x0311830f; WORD $0x0000 // jae LBB31_88, $785(%rip) + WORD $0xdb31 // xorl %ebx, %ebx + LONG $0x0003a8e9; BYTE $0x00 // jmp LBB31_90, $936(%rip) -LBB36_134: - WORD $0x894d; BYTE $0xda // movq %r11, %r10 - LONG $0xe0e28349 // andq $-32, %r10 - LONG $0xe0428d49 // leaq $-32(%r10), %rax - WORD $0x8948; BYTE $0xc1 // movq %rax, %rcx - LONG $0x05e9c148 // shrq $5, %rcx - WORD $0xff48; BYTE $0xc1 // incq %rcx - WORD $0x8941; BYTE $0xc8 // movl %ecx, %r8d - LONG $0x03e08341 // andl $3, %r8d - LONG $0x60f88348 // cmpq $96, %rax - LONG $0x0007830f; WORD $0x0000 // jae LBB36_136, $7(%rip) - WORD $0xc031 // xorl %eax, %eax - LONG $0x000061e9; BYTE $0x00 // jmp LBB36_138, $97(%rip) +LBB31_76: + LONG $0x0146c641; BYTE $0x2d // movb $45, $1(%r14) + WORD $0xd8f7 // negl %eax + WORD $0xf883; BYTE $0x0a // cmpl $10, %eax + LONG $0xfedc8d0f; WORD $0xffff // jge LBB31_75, $-292(%rip) -LBB36_136: - LONG $0xfce18348 // andq $-4, %rcx - LONG $0x2c048d4b // leaq (%r12,%r13), %rax - LONG $0x07148d48 // leaq (%rdi,%rax), %rdx - LONG $0x70c28348 // addq $112, %rdx - WORD $0xc031 // xorl %eax, %eax - QUAD $0xfffff8ba056f0f66 // movdqa $-1862(%rip), %xmm0 /* LCPI36_0(%rip) */ - QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90 +LBB31_77: + WORD $0x3004 // addb $48, %al + LONG $0x02468841 // movb %al, $2(%r14) + LONG $0x03c68349 // addq $3, %r14 + WORD $0x894d; BYTE $0xf0 // movq %r14, %r8 + LONG $0x000721e9; BYTE $0x00 // jmp LBB31_136, $1825(%rip) -LBB36_137: - LONG $0x447f0ff3; WORD $0x9002 // movdqu %xmm0, $-112(%rdx,%rax) - LONG $0x447f0ff3; WORD $0xa002 // movdqu %xmm0, $-96(%rdx,%rax) - LONG $0x447f0ff3; WORD $0xb002 // movdqu %xmm0, $-80(%rdx,%rax) - LONG $0x447f0ff3; WORD $0xc002 // movdqu %xmm0, $-64(%rdx,%rax) - LONG $0x447f0ff3; WORD $0xd002 // movdqu %xmm0, $-48(%rdx,%rax) - LONG $0x447f0ff3; WORD $0xe002 // movdqu %xmm0, $-32(%rdx,%rax) - LONG $0x447f0ff3; WORD $0xf002 // movdqu %xmm0, $-16(%rdx,%rax) - LONG $0x047f0ff3; BYTE $0x02 // movdqu %xmm0, (%rdx,%rax) - LONG $0x80e88348 // subq $-128, %rax - LONG $0xfcc18348 // addq $-4, %rcx - LONG $0xffc3850f; WORD $0xffff // jne LBB36_137, $-61(%rip) +LBB31_43: + WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax + LONG $0x64fd8341 // cmpl $100, %r13d + LONG $0xfdb7820f; WORD $0xffff // jb LBB31_29, $-585(%rip) -LBB36_138: - WORD $0x854d; BYTE $0xc0 // testq %r8, %r8 - LONG $0x0042840f; WORD $0x0000 // je LBB36_141, $66(%rip) - WORD $0x014c; BYTE $0xe8 // addq %r13, %rax - WORD $0x014c; BYTE $0xe0 // addq %r12, %rax - WORD $0x0148; BYTE $0xf8 // addq %rdi, %rax - LONG $0x10c08348 // addq $16, %rax - LONG $0x05e0c149 // shlq $5, %r8 - WORD $0xc931 // xorl %ecx, %ecx - QUAD $0xfffff84f056f0f66 // movdqa $-1969(%rip), %xmm0 /* LCPI36_0(%rip) */ - QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 +LBB31_44: + WORD $0xff48; BYTE $0xc8 // decq %rax + LONG $0x181d8d4c; WORD $0x003c; BYTE $0x00 // leaq $15384(%rip), %r11 /* _Digits(%rip) */ + QUAD $0x9090909090909090 // .p2align 4, 0x90 -LBB36_140: - LONG $0x447f0ff3; WORD $0xf008 // movdqu %xmm0, $-16(%rax,%rcx) - LONG $0x047f0ff3; BYTE $0x08 // movdqu %xmm0, (%rax,%rcx) - LONG $0x20c18348 // addq $32, %rcx - WORD $0x3949; BYTE $0xc8 // cmpq %rcx, %r8 - LONG $0xffe8850f; WORD $0xffff // jne LBB36_140, $-24(%rip) - -LBB36_141: - WORD $0x394d; BYTE $0xd3 // cmpq %r10, %r11 - LONG $0x00bf840f; WORD $0x0000 // je LBB36_145, $191(%rip) - LONG $0x18c3f641 // testb $24, %r11b - LONG $0x009c840f; WORD $0x0000 // je LBB36_143, $156(%rip) - -LBB36_131: - WORD $0x894d; BYTE $0xd8 // movq %r11, %r8 - LONG $0xf8e08349 // andq $-8, %r8 - WORD $0x014d; BYTE $0xc7 // addq %r8, %r15 - WORD $0x014d; BYTE $0xd5 // addq %r10, %r13 - WORD $0x014d; BYTE $0xe5 // addq %r12, %r13 - WORD $0x0149; BYTE $0xfd // addq %rdi, %r13 - WORD $0x894c; BYTE $0xc1 // movq %r8, %rcx - WORD $0x294c; BYTE $0xd1 // subq %r10, %rcx - WORD $0xd231 // xorl %edx, %edx - QUAD $0x303030303030b848; WORD $0x3030 // movabsq $3472328296227680304, %rax +LBB31_45: + WORD $0x8944; BYTE $0xe9 // movl %r13d, %ecx + LONG $0x1fc96948; WORD $0xeb85; BYTE $0x51 // imulq $1374389535, %rcx, %rcx + LONG $0x25e9c148 // shrq $37, %rcx + WORD $0xd96b; BYTE $0x64 // imull $100, %ecx, %ebx + WORD $0x8944; BYTE $0xea // movl %r13d, %edx + WORD $0xda29 // subl %ebx, %edx + LONG $0x14b70f41; BYTE $0x53 // movzwl (%r11,%rdx,2), %edx + LONG $0xff508966 // movw %dx, $-1(%rax) + LONG $0xfec08348 // addq $-2, %rax + LONG $0x0ffd8141; WORD $0x0027; BYTE $0x00 // cmpl $9999, %r13d + WORD $0x8941; BYTE $0xcd // movl %ecx, %r13d + LONG $0xffcd870f; WORD $0xffff // ja LBB31_45, $-51(%rip) + +LBB31_46: + WORD $0x6349; BYTE $0xc2 // movslq %r10d, %rax + WORD $0xf983; BYTE $0x0a // cmpl $10, %ecx + LONG $0x0022820f; WORD $0x0000 // jb LBB31_48, $34(%rip) + WORD $0xc989 // movl %ecx, %ecx + LONG $0xc8158d48; WORD $0x003b; BYTE $0x00 // leaq $15304(%rip), %rdx /* _Digits(%rip) */ + LONG $0x4a0cb70f // movzwl (%rdx,%rcx,2), %ecx + LONG $0x08894166 // movw %cx, (%r8) + WORD $0x0149; BYTE $0xc0 // addq %rax, %r8 + WORD $0x3949; BYTE $0xc4 // cmpq %rax, %r12 + LONG $0x00178c0f; WORD $0x0000 // jl LBB31_49, $23(%rip) + LONG $0x0006a1e9; BYTE $0x00 // jmp LBB31_136, $1697(%rip) - // .p2align 4, 0x90 -LBB36_132: - LONG $0x15448949; BYTE $0x00 // movq %rax, (%r13,%rdx) - LONG $0x08c28348 // addq $8, %rdx - WORD $0x3948; BYTE $0xd1 // cmpq %rdx, %rcx - LONG $0xffee850f; WORD $0xffff // jne LBB36_132, $-18(%rip) - WORD $0x394d; BYTE $0xc3 // cmpq %r8, %r11 - LONG $0x0065850f; WORD $0x0000 // jne LBB36_144, $101(%rip) - LONG $0x000070e9; BYTE $0x00 // jmp LBB36_145, $112(%rip) +LBB31_48: + WORD $0xc180; BYTE $0x30 // addb $48, %cl + WORD $0x8841; BYTE $0x08 // movb %cl, (%r8) + WORD $0x0149; BYTE $0xc0 // addq %rax, %r8 + WORD $0x3949; BYTE $0xc4 // cmpq %rax, %r12 + LONG $0x068f8d0f; WORD $0x0000 // jge LBB31_136, $1679(%rip) + +LBB31_49: + LONG $0x21048d4b // leaq (%r9,%r12), %rax + LONG $0x075c8d4c; BYTE $0x01 // leaq $1(%rdi,%rax), %r11 + WORD $0x394d; BYTE $0xc3 // cmpq %r8, %r11 + LONG $0xd8460f4d // cmovbeq %r8, %r11 + LONG $0x0f0c8d4a // leaq (%rdi,%r9), %rcx + WORD $0x014c; BYTE $0xe1 // addq %r12, %rcx + WORD $0x2949; BYTE $0xcb // subq %rcx, %r11 + LONG $0x20fb8349 // cmpq $32, %r11 + LONG $0x01f9820f; WORD $0x0000 // jb LBB31_85, $505(%rip) + WORD $0x894d; BYTE $0xda // movq %r11, %r10 + LONG $0xe0e28349 // andq $-32, %r10 + LONG $0xe04a8d49 // leaq $-32(%r10), %rcx + WORD $0x8948; BYTE $0xcb // movq %rcx, %rbx + LONG $0x05ebc148 // shrq $5, %rbx + WORD $0xff48; BYTE $0xc3 // incq %rbx + WORD $0xda89 // movl %ebx, %edx + WORD $0xe283; BYTE $0x07 // andl $7, %edx + LONG $0xe0f98148; WORD $0x0000; BYTE $0x00 // cmpq $224, %rcx + LONG $0x00ca830f; WORD $0x0000 // jae LBB31_78, $202(%rip) + WORD $0xc031 // xorl %eax, %eax + LONG $0x00016fe9; BYTE $0x00 // jmp LBB31_80, $367(%rip) -LBB36_19: - LONG $0x10ff8141; WORD $0x0027; BYTE $0x00 // cmpl $10000, %r15d - WORD $0x894c; BYTE $0xc9 // movq %r9, %rcx - LONG $0x00d98348 // sbbq $0, %rcx - LONG $0x05c18348 // addq $5, %rcx - LONG $0x10ff8141; WORD $0x0027; BYTE $0x00 // cmpl $10000, %r15d - LONG $0xfb79830f; WORD $0xffff // jae LBB36_13, $-1159(%rip) - WORD $0x8948; BYTE $0xc8 // movq %rcx, %rax - LONG $0xfffd0be9; BYTE $0xff // jmp LBB36_21, $-757(%rip) +LBB31_52: + LONG $0x0001b941; WORD $0x0000 // movl $1, %r9d + WORD $0xfe83; BYTE $0x0a // cmpl $10, %esi + LONG $0x0021820f; WORD $0x0000 // jb LBB31_55, $33(%rip) + LONG $0x0002b941; WORD $0x0000 // movl $2, %r9d + WORD $0xfe83; BYTE $0x64 // cmpl $100, %esi + LONG $0x0012820f; WORD $0x0000 // jb LBB31_55, $18(%rip) + LONG $0x0003b941; WORD $0x0000 // movl $3, %r9d + LONG $0x03e8fe81; WORD $0x0000 // cmpl $1000, %esi + LONG $0x01af830f; WORD $0x0000 // jae LBB31_86, $431(%rip) -LBB36_69: - WORD $0xff49; BYTE $0xc4 // incq %r12 - WORD $0x894c; BYTE $0xe1 // movq %r12, %rcx - LONG $0xe0e18348 // andq $-32, %rcx - LONG $0xe0518d48 // leaq $-32(%rcx), %rdx - WORD $0x8949; BYTE $0xd0 // movq %rdx, %r8 - LONG $0x05e8c149 // shrq $5, %r8 - WORD $0xff49; BYTE $0xc0 // incq %r8 - WORD $0x8945; BYTE $0xc7 // movl %r8d, %r15d - LONG $0x03e78341 // andl $3, %r15d - LONG $0x60fa8348 // cmpq $96, %rdx - LONG $0x0034830f; WORD $0x0000 // jae LBB36_71, $52(%rip) - WORD $0xd231 // xorl %edx, %edx - LONG $0x000080e9; BYTE $0x00 // jmp LBB36_73, $128(%rip) +LBB31_55: + WORD $0x014d; BYTE $0xc1 // addq %r8, %r9 + WORD $0x894c; BYTE $0xc8 // movq %r9, %rax + WORD $0xfe83; BYTE $0x64 // cmpl $100, %esi + LONG $0x003b820f; WORD $0x0000 // jb LBB31_58, $59(%rip) -LBB36_143: - WORD $0x014d; BYTE $0xd7 // addq %r10, %r15 - LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 +LBB31_56: + WORD $0xff48; BYTE $0xc8 // decq %rax + LONG $0x02158d4c; WORD $0x003b; BYTE $0x00 // leaq $15106(%rip), %r10 /* _Digits(%rip) */ + WORD $0x9090 // .p2align 4, 0x90 -LBB36_144: - LONG $0x3007c641 // movb $48, (%r15) - WORD $0xff49; BYTE $0xc7 // incq %r15 - WORD $0x394d; BYTE $0xcf // cmpq %r9, %r15 - LONG $0xfff0820f; WORD $0xffff // jb LBB36_144, $-16(%rip) +LBB31_57: + WORD $0xf389 // movl %esi, %ebx + WORD $0xf689 // movl %esi, %esi + LONG $0x1ff66948; WORD $0xeb85; BYTE $0x51 // imulq $1374389535, %rsi, %rsi + LONG $0x25eec148 // shrq $37, %rsi + WORD $0xce6b; BYTE $0x64 // imull $100, %esi, %ecx + WORD $0xda89 // movl %ebx, %edx + WORD $0xca29 // subl %ecx, %edx + LONG $0x0cb70f41; BYTE $0x52 // movzwl (%r10,%rdx,2), %ecx + LONG $0xff488966 // movw %cx, $-1(%rax) + LONG $0xfec08348 // addq $-2, %rax + LONG $0x270ffb81; WORD $0x0000 // cmpl $9999, %ebx + LONG $0xffd1870f; WORD $0xffff // ja LBB31_57, $-47(%rip) -LBB36_145: - WORD $0x894c; BYTE $0xc8 // movq %r9, %rax +LBB31_58: + WORD $0xfe83; BYTE $0x0a // cmpl $10, %esi + LONG $0x0016820f; WORD $0x0000 // jb LBB31_60, $22(%rip) + WORD $0xf089 // movl %esi, %eax + LONG $0xbf0d8d48; WORD $0x003a; BYTE $0x00 // leaq $15039(%rip), %rcx /* _Digits(%rip) */ + LONG $0x4104b70f // movzwl (%rcx,%rax,2), %eax + LONG $0x00894166 // movw %ax, (%r8) + LONG $0x000007e9; BYTE $0x00 // jmp LBB31_61, $7(%rip) -LBB36_146: - WORD $0xf829 // subl %edi, %eax +LBB31_60: + LONG $0x30c68040 // addb $48, %sil + WORD $0x8841; BYTE $0x30 // movb %sil, (%r8) -LBB36_147: - LONG $0x08c48348 // addq $8, %rsp - BYTE $0x5b // popq %rbx - WORD $0x5c41 // popq %r12 - WORD $0x5d41 // popq %r13 - WORD $0x5e41 // popq %r14 - WORD $0x5f41 // popq %r15 - BYTE $0x5d // popq %rbp - BYTE $0xc3 // retq +LBB31_61: + WORD $0x2941; BYTE $0xf9 // subl %edi, %r9d + WORD $0x8945; BYTE $0xc8 // movl %r9d, %r8d + LONG $0x000595e9; BYTE $0x00 // jmp LBB31_137, $1429(%rip) + +LBB31_62: + LONG $0x0004b941; WORD $0x0000 // movl $4, %r9d + LONG $0xfc4e8d49 // leaq $-4(%r14), %rcx + WORD $0xfb83; BYTE $0x64 // cmpl $100, %ebx + LONG $0xfbad820f; WORD $0xffff // jb LBB31_31, $-1107(%rip) + LONG $0xfffc53e9; BYTE $0xff // jmp LBB31_64, $-941(%rip) + +LBB31_78: + QUAD $0x000000f0078c8d48 // leaq $240(%rdi,%rax), %rcx + LONG $0xf8e38348 // andq $-8, %rbx + WORD $0xf748; BYTE $0xdb // negq %rbx + WORD $0xc031 // xorl %eax, %eax + QUAD $0xfffff89f056f0f66 // movdqa $-1889(%rip), %xmm0 /* LCPI31_0(%rip) */ + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 -LBB36_71: - LONG $0xfce08349 // andq $-4, %r8 - LONG $0x2f348d4a // leaq (%rdi,%r13), %rsi - LONG $0x72c68348 // addq $114, %rsi - WORD $0xd231 // xorl %edx, %edx - QUAD $0xfffff736056f0f66 // movdqa $-2250(%rip), %xmm0 /* LCPI36_0(%rip) */ - -LBB36_72: - LONG $0x447f0ff3; WORD $0x9016 // movdqu %xmm0, $-112(%rsi,%rdx) - LONG $0x447f0ff3; WORD $0xa016 // movdqu %xmm0, $-96(%rsi,%rdx) - LONG $0x447f0ff3; WORD $0xb016 // movdqu %xmm0, $-80(%rsi,%rdx) - LONG $0x447f0ff3; WORD $0xc016 // movdqu %xmm0, $-64(%rsi,%rdx) - LONG $0x447f0ff3; WORD $0xd016 // movdqu %xmm0, $-48(%rsi,%rdx) - LONG $0x447f0ff3; WORD $0xe016 // movdqu %xmm0, $-32(%rsi,%rdx) - LONG $0x447f0ff3; WORD $0xf016 // movdqu %xmm0, $-16(%rsi,%rdx) - LONG $0x047f0ff3; BYTE $0x16 // movdqu %xmm0, (%rsi,%rdx) - LONG $0x80ea8348 // subq $-128, %rdx - LONG $0xfcc08349 // addq $-4, %r8 - LONG $0xffc3850f; WORD $0xffff // jne LBB36_72, $-61(%rip) - -LBB36_73: - WORD $0x854d; BYTE $0xff // testq %r15, %r15 - LONG $0x0030840f; WORD $0x0000 // je LBB36_76, $48(%rip) - WORD $0x014c; BYTE $0xea // addq %r13, %rdx - WORD $0x0148; BYTE $0xfa // addq %rdi, %rdx - LONG $0x12c28348 // addq $18, %rdx - LONG $0x05e7c149 // shlq $5, %r15 - WORD $0xf631 // xorl %esi, %esi - QUAD $0xfffff6d8056f0f66 // movdqa $-2344(%rip), %xmm0 /* LCPI36_0(%rip) */ +LBB31_79: + QUAD $0xffff1001847f0ff3; BYTE $0xff // movdqu %xmm0, $-240(%rcx,%rax) + QUAD $0xffff2001847f0ff3; BYTE $0xff // movdqu %xmm0, $-224(%rcx,%rax) + QUAD $0xffff3001847f0ff3; BYTE $0xff // movdqu %xmm0, $-208(%rcx,%rax) + QUAD $0xffff4001847f0ff3; BYTE $0xff // movdqu %xmm0, $-192(%rcx,%rax) + QUAD $0xffff5001847f0ff3; BYTE $0xff // movdqu %xmm0, $-176(%rcx,%rax) + QUAD $0xffff6001847f0ff3; BYTE $0xff // movdqu %xmm0, $-160(%rcx,%rax) + QUAD $0xffff7001847f0ff3; BYTE $0xff // movdqu %xmm0, $-144(%rcx,%rax) + LONG $0x447f0ff3; WORD $0x8001 // movdqu %xmm0, $-128(%rcx,%rax) + LONG $0x447f0ff3; WORD $0x9001 // movdqu %xmm0, $-112(%rcx,%rax) + LONG $0x447f0ff3; WORD $0xa001 // movdqu %xmm0, $-96(%rcx,%rax) + LONG $0x447f0ff3; WORD $0xb001 // movdqu %xmm0, $-80(%rcx,%rax) + LONG $0x447f0ff3; WORD $0xc001 // movdqu %xmm0, $-64(%rcx,%rax) + LONG $0x447f0ff3; WORD $0xd001 // movdqu %xmm0, $-48(%rcx,%rax) + LONG $0x447f0ff3; WORD $0xe001 // movdqu %xmm0, $-32(%rcx,%rax) + LONG $0x447f0ff3; WORD $0xf001 // movdqu %xmm0, $-16(%rcx,%rax) + LONG $0x047f0ff3; BYTE $0x01 // movdqu %xmm0, (%rcx,%rax) + LONG $0x01000548; WORD $0x0000 // addq $256, %rax + LONG $0x08c38348 // addq $8, %rbx + LONG $0xff7c850f; WORD $0xffff // jne LBB31_79, $-132(%rip) + +LBB31_80: + WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx + LONG $0x0039840f; WORD $0x0000 // je LBB31_83, $57(%rip) + WORD $0x014c; BYTE $0xc8 // addq %r9, %rax + WORD $0x014c; BYTE $0xe0 // addq %r12, %rax + LONG $0x07448d48; BYTE $0x10 // leaq $16(%rdi,%rax), %rax + WORD $0xf748; BYTE $0xda // negq %rdx + QUAD $0xfffff7ed056f0f66 // movdqa $-2067(%rip), %xmm0 /* LCPI31_0(%rip) */ + QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 -LBB36_75: - LONG $0x447f0ff3; WORD $0xf032 // movdqu %xmm0, $-16(%rdx,%rsi) - LONG $0x047f0ff3; BYTE $0x32 // movdqu %xmm0, (%rdx,%rsi) - LONG $0x20c68348 // addq $32, %rsi - WORD $0x3949; BYTE $0xf7 // cmpq %rsi, %r15 - LONG $0xffe8850f; WORD $0xffff // jne LBB36_75, $-24(%rip) +LBB31_82: + LONG $0x407f0ff3; BYTE $0xf0 // movdqu %xmm0, $-16(%rax) + LONG $0x007f0ff3 // movdqu %xmm0, (%rax) + LONG $0x20c08348 // addq $32, %rax + WORD $0xff48; BYTE $0xc2 // incq %rdx + LONG $0xffea850f; WORD $0xffff // jne LBB31_82, $-22(%rip) -LBB36_76: - WORD $0x0149; BYTE $0xc9 // addq %rcx, %r9 - WORD $0x3949; BYTE $0xcc // cmpq %rcx, %r12 - WORD $0x8949; BYTE $0xdc // movq %rbx, %r12 - LONG $0x0020840f; WORD $0x0000 // je LBB36_79, $32(%rip) +LBB31_83: + WORD $0x394d; BYTE $0xda // cmpq %r11, %r10 + LONG $0x0483840f; WORD $0x0000 // je LBB31_136, $1155(%rip) + WORD $0x014c; BYTE $0xd6 // addq %r10, %rsi + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 -LBB36_77: - WORD $0x0144; BYTE $0xd1 // addl %r10d, %ecx - WORD $0xd9f7 // negl %ecx - QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90 +LBB31_85: + WORD $0x06c6; BYTE $0x30 // movb $48, (%rsi) + WORD $0xff48; BYTE $0xc6 // incq %rsi + WORD $0x394c; BYTE $0xc6 // cmpq %r8, %rsi + LONG $0xfff1820f; WORD $0xffff // jb LBB31_85, $-15(%rip) + LONG $0x00045ee9; BYTE $0x00 // jmp LBB31_136, $1118(%rip) -LBB36_78: - LONG $0x3001c641 // movb $48, (%r9) - WORD $0xff49; BYTE $0xc1 // incq %r9 - WORD $0xc9ff // decl %ecx - LONG $0xfff1850f; WORD $0xffff // jne LBB36_78, $-15(%rip) +LBB31_86: + LONG $0x2710fe81; WORD $0x0000 // cmpl $10000, %esi + WORD $0x894c; BYTE $0xc0 // movq %r8, %rax + LONG $0x00d88348 // sbbq $0, %rax + LONG $0x05c08348 // addq $5, %rax + LONG $0x2710fe81; WORD $0x0000 // cmpl $10000, %esi + LONG $0xfc4a830f; WORD $0xffff // jae LBB31_37, $-950(%rip) + WORD $0x8949; BYTE $0xc1 // movq %rax, %r9 + LONG $0xfffe3be9; BYTE $0xff // jmp LBB31_56, $-453(%rip) -LBB36_79: - WORD $0x894d; BYTE $0xe5 // movq %r12, %r13 - LONG $0x213c8d4f // leaq (%r9,%r12), %r15 - LONG $0x0027103d; BYTE $0x00 // cmpl $10000, %eax - LONG $0x0052820f; WORD $0x0000 // jb LBB36_80, $82(%rip) - WORD $0xc289 // movl %eax, %edx - LONG $0x1759bc41; WORD $0xd1b7 // movl $3518437209, %r12d - LONG $0xe2af0f4c // imulq %rdx, %r12 - LONG $0x2decc149 // shrq $45, %r12 - LONG $0xf0d46941; WORD $0xffd8; BYTE $0xff // imull $-10000, %r12d, %edx - WORD $0xc201 // addl %eax, %edx - LONG $0x004e840f; WORD $0x0000 // je LBB36_82, $78(%rip) - WORD $0xd089 // movl %edx, %eax - LONG $0x1fc06948; WORD $0xeb85; BYTE $0x51 // imulq $1374389535, %rax, %rax - LONG $0x25e8c148 // shrq $37, %rax - WORD $0xf06b; BYTE $0x64 // imull $100, %eax, %esi - WORD $0xf229 // subl %esi, %edx - LONG $0x17358d48; WORD $0x003b; BYTE $0x00 // leaq $15127(%rip), %rsi /* _Digits(%rip) */ - LONG $0x5614b70f // movzwl (%rsi,%rdx,2), %edx - LONG $0x57894166; BYTE $0xfe // movw %dx, $-2(%r15) - LONG $0x4604b70f // movzwl (%rsi,%rax,2), %eax - LONG $0x47894166; BYTE $0xfc // movw %ax, $-4(%r15) - WORD $0x3145; BYTE $0xc0 // xorl %r8d, %r8d - LONG $0x000021e9; BYTE $0x00 // jmp LBB36_84, $33(%rip) +LBB31_88: + QUAD $0x000000f239848d49 // leaq $242(%r9,%rdi), %rax + LONG $0xf8e68349 // andq $-8, %r14 + WORD $0xf749; BYTE $0xde // negq %r14 + WORD $0xdb31 // xorl %ebx, %ebx + QUAD $0xfffff75e056f0f66 // movdqa $-2210(%rip), %xmm0 /* LCPI31_0(%rip) */ + +LBB31_89: + QUAD $0xffff1018847f0ff3; BYTE $0xff // movdqu %xmm0, $-240(%rax,%rbx) + QUAD $0xffff2018847f0ff3; BYTE $0xff // movdqu %xmm0, $-224(%rax,%rbx) + QUAD $0xffff3018847f0ff3; BYTE $0xff // movdqu %xmm0, $-208(%rax,%rbx) + QUAD $0xffff4018847f0ff3; BYTE $0xff // movdqu %xmm0, $-192(%rax,%rbx) + QUAD $0xffff5018847f0ff3; BYTE $0xff // movdqu %xmm0, $-176(%rax,%rbx) + QUAD $0xffff6018847f0ff3; BYTE $0xff // movdqu %xmm0, $-160(%rax,%rbx) + QUAD $0xffff7018847f0ff3; BYTE $0xff // movdqu %xmm0, $-144(%rax,%rbx) + LONG $0x447f0ff3; WORD $0x8018 // movdqu %xmm0, $-128(%rax,%rbx) + LONG $0x447f0ff3; WORD $0x9018 // movdqu %xmm0, $-112(%rax,%rbx) + LONG $0x447f0ff3; WORD $0xa018 // movdqu %xmm0, $-96(%rax,%rbx) + LONG $0x447f0ff3; WORD $0xb018 // movdqu %xmm0, $-80(%rax,%rbx) + LONG $0x447f0ff3; WORD $0xc018 // movdqu %xmm0, $-64(%rax,%rbx) + LONG $0x447f0ff3; WORD $0xd018 // movdqu %xmm0, $-48(%rax,%rbx) + LONG $0x447f0ff3; WORD $0xe018 // movdqu %xmm0, $-32(%rax,%rbx) + LONG $0x447f0ff3; WORD $0xf018 // movdqu %xmm0, $-16(%rax,%rbx) + LONG $0x047f0ff3; BYTE $0x18 // movdqu %xmm0, (%rax,%rbx) + LONG $0x00c38148; WORD $0x0001; BYTE $0x00 // addq $256, %rbx + LONG $0x08c68349 // addq $8, %r14 + LONG $0xff7b850f; WORD $0xffff // jne LBB31_89, $-133(%rip) + +LBB31_90: + WORD $0x854d; BYTE $0xdb // testq %r11, %r11 + LONG $0x0029840f; WORD $0x0000 // je LBB31_93, $41(%rip) + WORD $0x014c; BYTE $0xcb // addq %r9, %rbx + LONG $0x1f448d48; BYTE $0x12 // leaq $18(%rdi,%rbx), %rax + WORD $0xf749; BYTE $0xdb // negq %r11 + QUAD $0xfffff6bd056f0f66 // movdqa $-2371(%rip), %xmm0 /* LCPI31_0(%rip) */ + +LBB31_92: + LONG $0x407f0ff3; BYTE $0xf0 // movdqu %xmm0, $-16(%rax) + LONG $0x007f0ff3 // movdqu %xmm0, (%rax) + LONG $0x20c08348 // addq $32, %rax + WORD $0xff49; BYTE $0xc3 // incq %r11 + LONG $0xffea850f; WORD $0xffff // jne LBB31_92, $-22(%rip) -LBB36_80: - WORD $0x3145; BYTE $0xc0 // xorl %r8d, %r8d - WORD $0x894c; BYTE $0xfe // movq %r15, %rsi - WORD $0x8941; BYTE $0xc4 // movl %eax, %r12d - LONG $0x64fc8341 // cmpl $100, %r12d - LONG $0x001c830f; WORD $0x0000 // jae LBB36_87, $28(%rip) +LBB31_93: + WORD $0x014d; BYTE $0xf8 // addq %r15, %r8 + WORD $0x394c; BYTE $0xfe // cmpq %r15, %rsi + LONG $0x001b840f; WORD $0x0000 // je LBB31_96, $27(%rip) -LBB36_86: - WORD $0x8944; BYTE $0xe0 // movl %r12d, %eax - LONG $0x000054e9; BYTE $0x00 // jmp LBB36_89, $84(%rip) +LBB31_94: + WORD $0x0145; BYTE $0xd7 // addl %r10d, %r15d + WORD $0xf741; BYTE $0xdf // negl %r15d + LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 -LBB36_82: - LONG $0x0004b841; WORD $0x0000 // movl $4, %r8d +LBB31_95: + LONG $0x3000c641 // movb $48, (%r8) + WORD $0xff49; BYTE $0xc0 // incq %r8 + WORD $0xff41; BYTE $0xcf // decl %r15d + LONG $0xfff0850f; WORD $0xffff // jne LBB31_95, $-16(%rip) + +LBB31_96: + LONG $0x20048d4b // leaq (%r8,%r12), %rax + LONG $0x10fd8141; WORD $0x0027; BYTE $0x00 // cmpl $10000, %r13d + LONG $0x0063820f; WORD $0x0000 // jb LBB31_99, $99(%rip) + WORD $0x8944; BYTE $0xe9 // movl %r13d, %ecx + LONG $0x1759bb41; WORD $0xd1b7 // movl $3518437209, %r11d + LONG $0xd9af0f4c // imulq %rcx, %r11 + LONG $0x2debc149 // shrq $45, %r11 + LONG $0xf0cb6941; WORD $0xffd8; BYTE $0xff // imull $-10000, %r11d, %ecx + WORD $0x0144; BYTE $0xe9 // addl %r13d, %ecx + LONG $0x0190840f; WORD $0x0000 // je LBB31_101, $400(%rip) + WORD $0xca89 // movl %ecx, %edx + LONG $0x1fd26948; WORD $0xeb85; BYTE $0x51 // imulq $1374389535, %rdx, %rdx + LONG $0x25eac148 // shrq $37, %rdx + WORD $0xda6b; BYTE $0x64 // imull $100, %edx, %ebx + WORD $0xd929 // subl %ebx, %ecx + LONG $0x051d8d48; WORD $0x0038; BYTE $0x00 // leaq $14341(%rip), %rbx /* _Digits(%rip) */ + LONG $0x4b0cb70f // movzwl (%rbx,%rcx,2), %ecx + LONG $0xfe488966 // movw %cx, $-2(%rax) + LONG $0x530cb70f // movzwl (%rbx,%rdx,2), %ecx + LONG $0xfc488966 // movw %cx, $-4(%rax) + WORD $0x3145; BYTE $0xc9 // xorl %r9d, %r9d + LONG $0xfcc08348 // addq $-4, %rax + LONG $0x64fb8341 // cmpl $100, %r11d + LONG $0x0018830f; WORD $0x0000 // jae LBB31_103, $24(%rip) -LBB36_84: - LONG $0xfc778d49 // leaq $-4(%r15), %rsi - LONG $0x64fc8341 // cmpl $100, %r12d - LONG $0xffe4820f; WORD $0xffff // jb LBB36_86, $-28(%rip) +LBB31_100: + WORD $0x8944; BYTE $0xd9 // movl %r11d, %ecx + LONG $0x00004ee9; BYTE $0x00 // jmp LBB31_105, $78(%rip) -LBB36_87: - WORD $0xff48; BYTE $0xce // decq %rsi - LONG $0xc4158d48; WORD $0x003a; BYTE $0x00 // leaq $15044(%rip), %rdx /* _Digits(%rip) */ - LONG $0x90909090 // .p2align 4, 0x90 +LBB31_99: + WORD $0x3145; BYTE $0xc9 // xorl %r9d, %r9d + WORD $0x8945; BYTE $0xeb // movl %r13d, %r11d + LONG $0x64fb8341 // cmpl $100, %r11d + LONG $0xffe8820f; WORD $0xffff // jb LBB31_100, $-24(%rip) -LBB36_88: - WORD $0x8944; BYTE $0xe0 // movl %r12d, %eax - LONG $0x1fc06948; WORD $0xeb85; BYTE $0x51 // imulq $1374389535, %rax, %rax - LONG $0x25e8c148 // shrq $37, %rax - WORD $0xd86b; BYTE $0x64 // imull $100, %eax, %ebx - WORD $0x8944; BYTE $0xe1 // movl %r12d, %ecx - WORD $0xd929 // subl %ebx, %ecx - LONG $0x4a0cb70f // movzwl (%rdx,%rcx,2), %ecx - LONG $0xff4e8966 // movw %cx, $-1(%rsi) - LONG $0xfec68348 // addq $-2, %rsi - LONG $0x0ffc8141; WORD $0x0027; BYTE $0x00 // cmpl $9999, %r12d - WORD $0x8941; BYTE $0xc4 // movl %eax, %r12d - LONG $0xffce870f; WORD $0xffff // ja LBB36_88, $-50(%rip) +LBB31_103: + WORD $0xff48; BYTE $0xc8 // decq %rax + LONG $0xc2158d48; WORD $0x0037; BYTE $0x00 // leaq $14274(%rip), %rdx /* _Digits(%rip) */ + WORD $0x9090 // .p2align 4, 0x90 -LBB36_89: - WORD $0xf883; BYTE $0x0a // cmpl $10, %eax - LONG $0x0016820f; WORD $0x0000 // jb LBB36_91, $22(%rip) - WORD $0xc089 // movl %eax, %eax - LONG $0x7c0d8d48; WORD $0x003a; BYTE $0x00 // leaq $14972(%rip), %rcx /* _Digits(%rip) */ +LBB31_104: + WORD $0x8944; BYTE $0xd9 // movl %r11d, %ecx + LONG $0x1fc96948; WORD $0xeb85; BYTE $0x51 // imulq $1374389535, %rcx, %rcx + LONG $0x25e9c148 // shrq $37, %rcx + WORD $0xd96b; BYTE $0x64 // imull $100, %ecx, %ebx + WORD $0x8944; BYTE $0xde // movl %r11d, %esi + WORD $0xde29 // subl %ebx, %esi + LONG $0x7234b70f // movzwl (%rdx,%rsi,2), %esi + LONG $0xff708966 // movw %si, $-1(%rax) + LONG $0xfec08348 // addq $-2, %rax + LONG $0x0ffb8141; WORD $0x0027; BYTE $0x00 // cmpl $9999, %r11d + WORD $0x8941; BYTE $0xcb // movl %ecx, %r11d + LONG $0xffce870f; WORD $0xffff // ja LBB31_104, $-50(%rip) + +LBB31_105: + WORD $0xf983; BYTE $0x0a // cmpl $10, %ecx + LONG $0x0016820f; WORD $0x0000 // jb LBB31_107, $22(%rip) + WORD $0xc889 // movl %ecx, %eax + LONG $0x7c0d8d48; WORD $0x0037; BYTE $0x00 // leaq $14204(%rip), %rcx /* _Digits(%rip) */ LONG $0x4104b70f // movzwl (%rcx,%rax,2), %eax - LONG $0x01894166 // movw %ax, (%r9) - LONG $0x000005e9; BYTE $0x00 // jmp LBB36_92, $5(%rip) - -LBB36_91: - WORD $0x3004 // addb $48, %al - WORD $0x8841; BYTE $0x01 // movb %al, (%r9) - -LBB36_92: - WORD $0x294d; BYTE $0xc7 // subq %r8, %r15 - WORD $0x294d; BYTE $0xc5 // subq %r8, %r13 - WORD $0xff49; BYTE $0xc5 // incq %r13 - LONG $0xd06d894c // movq %r13, $-48(%rbp) - LONG $0x18048d43 // leal (%r8,%r11), %eax - WORD $0xd8f6 // negb %al - LONG $0x03248d47 // leal (%r11,%r8), %r12d - WORD $0xf741; BYTE $0xdc // negl %r12d - LONG $0x032c8d47 // leal (%r11,%r8), %r13d - WORD $0xff41; BYTE $0xcd // decl %r13d - LONG $0x03348d43 // leal (%r11,%r8), %esi - WORD $0xc683; BYTE $0xfe // addl $-2, %esi - WORD $0xc931 // xorl %ecx, %ecx - - // .p2align 4, 0x90 -LBB36_93: - WORD $0xc389 // movl %eax, %ebx - WORD $0x438d; BYTE $0x03 // leal $3(%rbx), %eax - WORD $0xc6ff // incl %esi - LONG $0x0f7c8041; WORD $0x30ff // cmpb $48, $-1(%r15,%rcx) - LONG $0xff498d48 // leaq $-1(%rcx), %rcx - LONG $0xffe9840f; WORD $0xffff // je LBB36_93, $-23(%rip) - LONG $0x0f048d49 // leaq (%r15,%rcx), %rax - WORD $0xff48; BYTE $0xc0 // incq %rax - WORD $0x8545; BYTE $0xd2 // testl %r10d, %r10d - LONG $0xfdec8e0f; WORD $0xffff // jle LBB36_146, $-532(%rip) - WORD $0x2945; BYTE $0xc6 // subl %r8d, %r14d - LONG $0x0e148d41 // leal (%r14,%rcx), %edx - WORD $0xc2ff // incl %edx - WORD $0x3941; BYTE $0xd2 // cmpl %edx, %r10d - LONG $0x002b8d0f; WORD $0x0000 // jge LBB36_96, $43(%rip) - WORD $0x6349; BYTE $0xc4 // movslq %r12d, %rax - LONG $0x081c8d4c // leaq (%rax,%rcx), %r11 - WORD $0xff49; BYTE $0xc3 // incq %r11 - WORD $0x8545; BYTE $0xdb // testl %r11d, %r11d - LONG $0x00ec8e0f; WORD $0x0000 // jle LBB36_114, $236(%rip) - WORD $0x8945; BYTE $0xd8 // movl %r11d, %r8d - LONG $0xff508d49 // leaq $-1(%r8), %rdx - LONG $0x03fa8348 // cmpq $3, %rdx - LONG $0x0073830f; WORD $0x0000 // jae LBB36_115, $115(%rip) - WORD $0xd231 // xorl %edx, %edx - LONG $0x000098e9; BYTE $0x00 // jmp LBB36_111, $152(%rip) + LONG $0x00894166 // movw %ax, (%r8) + LONG $0x000006e9; BYTE $0x00 // jmp LBB31_108, $6(%rip) + +LBB31_107: + WORD $0xc180; BYTE $0x30 // addb $48, %cl + WORD $0x8841; BYTE $0x08 // movb %cl, (%r8) + +LBB31_108: + WORD $0x294d; BYTE $0xcc // subq %r9, %r12 + LONG $0x24548d49; BYTE $0x01 // leaq $1(%r12), %rdx + LONG $0x24748d49; BYTE $0x11 // leaq $17(%r12), %rsi + LONG $0x24448d49; BYTE $0x02 // leaq $2(%r12), %rax + LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 -LBB36_96: - WORD $0x8945; BYTE $0xea // movl %r13d, %r10d - WORD $0x2949; BYTE $0xca // subq %rcx, %r10 +LBB31_109: + WORD $0xff48; BYTE $0xce // decq %rsi + WORD $0xff48; BYTE $0xca // decq %rdx + WORD $0xff48; BYTE $0xc8 // decq %rax + LONG $0x207c8043; WORD $0x30ff // cmpb $48, $-1(%r8,%r12) + LONG $0x24648d4d; BYTE $0xff // leaq $-1(%r12), %r12 + LONG $0xffe6840f; WORD $0xffff // je LBB31_109, $-26(%rip) + LONG $0x100c8d4d // leaq (%r8,%rdx), %r9 WORD $0x8545; BYTE $0xd2 // testl %r10d, %r10d - LONG $0xfda08e0f; WORD $0xffff // jle LBB36_146, $-608(%rip) - LONG $0x031c8d43 // leal (%r11,%r8), %ebx - WORD $0xc383; BYTE $0xfe // addl $-2, %ebx - WORD $0x2948; BYTE $0xcb // subq %rcx, %rbx - WORD $0xd231 // xorl %edx, %edx - WORD $0xfb83; BYTE $0x1f // cmpl $31, %ebx - LONG $0x0198820f; WORD $0x0000 // jb LBB36_106, $408(%rip) - LONG $0x03348d47 // leal (%r11,%r8), %r14d - LONG $0xfec68341 // addl $-2, %r14d - WORD $0x2949; BYTE $0xce // subq %rcx, %r14 + LONG $0x00938e0f; WORD $0x0000 // jle LBB31_115, $147(%rip) + WORD $0x8944; BYTE $0xc9 // movl %r9d, %ecx + WORD $0x2944; BYTE $0xc1 // subl %r8d, %ecx + WORD $0xcb89 // movl %ecx, %ebx + WORD $0x2944; BYTE $0xd3 // subl %r10d, %ebx + LONG $0x00278e0f; WORD $0x0000 // jle LBB31_116, $39(%rip) + WORD $0xdb85 // testl %ebx, %ebx + LONG $0x00fa8e0f; WORD $0x0000 // jle LBB31_127, $250(%rip) WORD $0x8941; BYTE $0xdb // movl %ebx, %r11d - WORD $0xff49; BYTE $0xc3 // incq %r11 - WORD $0x894c; BYTE $0xda // movq %r11, %rdx - LONG $0xe0e28348 // andq $-32, %rdx - LONG $0xd04d034c // addq $-48(%rbp), %r9 - WORD $0xf089 // movl %esi, %eax - WORD $0xff48; BYTE $0xc0 // incq %rax - LONG $0xe0e08348 // andq $-32, %rax - WORD $0x014c; BYTE $0xc8 // addq %r9, %rax - LONG $0xe0728d48 // leaq $-32(%rdx), %rsi - WORD $0x8949; BYTE $0xf0 // movq %rsi, %r8 - LONG $0x05e8c149 // shrq $5, %r8 - WORD $0xff49; BYTE $0xc0 // incq %r8 - LONG $0x60fe8348 // cmpq $96, %rsi - LONG $0x0085830f; WORD $0x0000 // jae LBB36_100, $133(%rip) - WORD $0x3145; BYTE $0xc9 // xorl %r9d, %r9d - LONG $0x0000e3e9; BYTE $0x00 // jmp LBB36_102, $227(%rip) + LONG $0xff4b8d49 // leaq $-1(%r11), %rcx + WORD $0x8945; BYTE $0xd9 // movl %r11d, %r9d + LONG $0x03e18341 // andl $3, %r9d + LONG $0x03f98348 // cmpq $3, %rcx + LONG $0x0083830f; WORD $0x0000 // jae LBB31_121, $131(%rip) + WORD $0xc931 // xorl %ecx, %ecx + LONG $0x0000ade9; BYTE $0x00 // jmp LBB31_124, $173(%rip) + +LBB31_116: + WORD $0x8945; BYTE $0xd6 // movl %r10d, %r14d + WORD $0x2941; BYTE $0xce // subl %ecx, %r14d + LONG $0x004f8e0f; WORD $0x0000 // jle LBB31_115, $79(%rip) + WORD $0x0145; BYTE $0xc2 // addl %r8d, %r10d + WORD $0x8945; BYTE $0xcb // movl %r9d, %r11d + WORD $0xf741; BYTE $0xd3 // notl %r11d + WORD $0x0145; BYTE $0xd3 // addl %r10d, %r11d + WORD $0xc031 // xorl %eax, %eax + LONG $0x1efb8341 // cmpl $30, %r11d + LONG $0x01a5860f; WORD $0x0000 // jbe LBB31_134, $421(%rip) + WORD $0xff49; BYTE $0xc3 // incq %r11 + WORD $0x894c; BYTE $0xd8 // movq %r11, %rax + LONG $0xe0e08348 // andq $-32, %rax + LONG $0x000c8d4d // leaq (%r8,%rax), %r9 + LONG $0xe0488d48 // leaq $-32(%rax), %rcx + WORD $0x8949; BYTE $0xcf // movq %rcx, %r15 + LONG $0x05efc149 // shrq $5, %r15 + WORD $0xff49; BYTE $0xc7 // incq %r15 + WORD $0x8945; BYTE $0xfa // movl %r15d, %r10d + LONG $0x07e28341 // andl $7, %r10d + LONG $0xe0f98148; WORD $0x0000; BYTE $0x00 // cmpq $224, %rcx + LONG $0x0097830f; WORD $0x0000 // jae LBB31_128, $151(%rip) + WORD $0xc931 // xorl %ecx, %ecx + LONG $0x00012de9; BYTE $0x00 // jmp LBB31_130, $301(%rip) + +LBB31_115: + WORD $0x894d; BYTE $0xc8 // movq %r9, %r8 + LONG $0x000180e9; BYTE $0x00 // jmp LBB31_136, $384(%rip) + +LBB31_101: + LONG $0x0004b941; WORD $0x0000 // movl $4, %r9d + LONG $0xfcc08348 // addq $-4, %rax + LONG $0x64fb8341 // cmpl $100, %r11d + LONG $0xfe96820f; WORD $0xffff // jb LBB31_100, $-362(%rip) + LONG $0xfffea9e9; BYTE $0xff // jmp LBB31_103, $-343(%rip) -LBB36_115: +LBB31_121: LONG $0xfce38341 // andl $-4, %r11d WORD $0xf749; BYTE $0xdb // negq %r11 - WORD $0xd231 // xorl %edx, %edx - LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 + WORD $0xc931 // xorl %ecx, %ecx + QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90 -LBB36_116: - LONG $0x17048d49 // leaq (%r15,%rdx), %rax - LONG $0xfd01748b // movl $-3(%rcx,%rax), %esi - LONG $0xfe017489 // movl %esi, $-2(%rcx,%rax) - LONG $0xfcc28348 // addq $-4, %rdx - WORD $0x3949; BYTE $0xd3 // cmpq %rdx, %r11 - LONG $0xffe7850f; WORD $0xffff // jne LBB36_116, $-25(%rip) - WORD $0xf748; BYTE $0xda // negq %rdx +LBB31_122: + LONG $0x081c8d49 // leaq (%r8,%rcx), %rbx + LONG $0xfc1a748b // movl $-4(%rdx,%rbx), %esi + LONG $0xfd1a7489 // movl %esi, $-3(%rdx,%rbx) + LONG $0xfcc18348 // addq $-4, %rcx + WORD $0x3949; BYTE $0xcb // cmpq %rcx, %r11 + LONG $0xffe7850f; WORD $0xffff // jne LBB31_122, $-25(%rip) + WORD $0xf748; BYTE $0xd9 // negq %rcx -LBB36_111: - LONG $0x03c0f641 // testb $3, %r8b - LONG $0x0032840f; WORD $0x0000 // je LBB36_114, $50(%rip) - LONG $0xc3b60f44 // movzbl %bl, %r8d - LONG $0x03e08341 // andl $3, %r8d - WORD $0xf749; BYTE $0xd8 // negq %r8 - WORD $0x894c; BYTE $0xfe // movq %r15, %rsi - WORD $0x2948; BYTE $0xd6 // subq %rdx, %rsi - WORD $0xd231 // xorl %edx, %edx - LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 +LBB31_124: + WORD $0x854d; BYTE $0xc9 // testq %r9, %r9 + LONG $0x0025840f; WORD $0x0000 // je LBB31_127, $37(%rip) + WORD $0xf749; BYTE $0xd9 // negq %r9 + WORD $0x894c; BYTE $0xc2 // movq %r8, %rdx + WORD $0x2948; BYTE $0xca // subq %rcx, %rdx + WORD $0xc931 // xorl %ecx, %ecx -LBB36_113: - LONG $0x161c8d48 // leaq (%rsi,%rdx), %rbx - LONG $0x1904b60f // movzbl (%rcx,%rbx), %eax - LONG $0x01194488 // movb %al, $1(%rcx,%rbx) - WORD $0xff48; BYTE $0xca // decq %rdx - WORD $0x3949; BYTE $0xd0 // cmpq %rdx, %r8 - LONG $0xffe8850f; WORD $0xffff // jne LBB36_113, $-24(%rip) + // .p2align 4, 0x90 +LBB31_126: + LONG $0x0a348d48 // leaq (%rdx,%rcx), %rsi + LONG $0x1cb60f41; BYTE $0x34 // movzbl (%r12,%rsi), %ebx + LONG $0x345c8841; BYTE $0x01 // movb %bl, $1(%r12,%rsi) + WORD $0xff48; BYTE $0xc9 // decq %rcx + WORD $0x3949; BYTE $0xc9 // cmpq %rcx, %r9 + LONG $0xffe6850f; WORD $0xffff // jne LBB31_126, $-26(%rip) + +LBB31_127: + WORD $0x6349; BYTE $0xca // movslq %r10d, %rcx + LONG $0x0804c641; BYTE $0x2e // movb $46, (%r8,%rcx) + WORD $0x0149; BYTE $0xc0 // addq %rax, %r8 + LONG $0x0000f8e9; BYTE $0x00 // jmp LBB31_136, $248(%rip) + +LBB31_128: + LONG $0xf8e78349 // andq $-8, %r15 + WORD $0xf749; BYTE $0xdf // negq %r15 + WORD $0xc931 // xorl %ecx, %ecx + QUAD $0xfffff425056f0f66 // movdqa $-3035(%rip), %xmm0 /* LCPI31_0(%rip) */ + +LBB31_129: + LONG $0x081c8d49 // leaq (%r8,%rcx), %rbx + LONG $0x047f0ff3; BYTE $0x1a // movdqu %xmm0, (%rdx,%rbx) + LONG $0x447f0ff3; WORD $0x101a // movdqu %xmm0, $16(%rdx,%rbx) + LONG $0x447f0ff3; WORD $0x201a // movdqu %xmm0, $32(%rdx,%rbx) + LONG $0x447f0ff3; WORD $0x301a // movdqu %xmm0, $48(%rdx,%rbx) + LONG $0x447f0ff3; WORD $0x401a // movdqu %xmm0, $64(%rdx,%rbx) + LONG $0x447f0ff3; WORD $0x501a // movdqu %xmm0, $80(%rdx,%rbx) + LONG $0x447f0ff3; WORD $0x601a // movdqu %xmm0, $96(%rdx,%rbx) + LONG $0x447f0ff3; WORD $0x701a // movdqu %xmm0, $112(%rdx,%rbx) + QUAD $0x0000801a847f0ff3; BYTE $0x00 // movdqu %xmm0, $128(%rdx,%rbx) + QUAD $0x0000901a847f0ff3; BYTE $0x00 // movdqu %xmm0, $144(%rdx,%rbx) + QUAD $0x0000a01a847f0ff3; BYTE $0x00 // movdqu %xmm0, $160(%rdx,%rbx) + QUAD $0x0000b01a847f0ff3; BYTE $0x00 // movdqu %xmm0, $176(%rdx,%rbx) + QUAD $0x0000c01a847f0ff3; BYTE $0x00 // movdqu %xmm0, $192(%rdx,%rbx) + QUAD $0x0000d01a847f0ff3; BYTE $0x00 // movdqu %xmm0, $208(%rdx,%rbx) + QUAD $0x0000e01a847f0ff3; BYTE $0x00 // movdqu %xmm0, $224(%rdx,%rbx) + QUAD $0x0000f01a847f0ff3; BYTE $0x00 // movdqu %xmm0, $240(%rdx,%rbx) + LONG $0x00c18148; WORD $0x0001; BYTE $0x00 // addq $256, %rcx + LONG $0x08c78349 // addq $8, %r15 + LONG $0xff74850f; WORD $0xffff // jne LBB31_129, $-140(%rip) + +LBB31_130: + WORD $0x0149; BYTE $0xd1 // addq %rdx, %r9 + WORD $0x854d; BYTE $0xd2 // testq %r10, %r10 + LONG $0x0029840f; WORD $0x0000 // je LBB31_133, $41(%rip) + WORD $0x0149; BYTE $0xc8 // addq %rcx, %r8 + WORD $0x0149; BYTE $0xf0 // addq %rsi, %r8 + WORD $0xf749; BYTE $0xda // negq %r10 + QUAD $0xfffff37c056f0f66 // movdqa $-3204(%rip), %xmm0 /* LCPI31_0(%rip) */ -LBB36_114: - WORD $0x8944; BYTE $0xd0 // movl %r10d, %eax - LONG $0x0104c641; BYTE $0x2e // movb $46, (%r9,%rax) - LONG $0x0f048d49 // leaq (%r15,%rcx), %rax - LONG $0x02c08348 // addq $2, %rax - LONG $0xfffcc6e9; BYTE $0xff // jmp LBB36_146, $-826(%rip) +LBB31_132: + LONG $0x7f0f41f3; WORD $0xf040 // movdqu %xmm0, $-16(%r8) + LONG $0x7f0f41f3; BYTE $0x00 // movdqu %xmm0, (%r8) + LONG $0x20c08349 // addq $32, %r8 + WORD $0xff49; BYTE $0xc2 // incq %r10 + LONG $0xffe8850f; WORD $0xffff // jne LBB31_132, $-24(%rip) -LBB36_100: - WORD $0x8944; BYTE $0xf3 // movl %r14d, %ebx - WORD $0xff48; BYTE $0xc3 // incq %rbx - LONG $0xe0e38348 // andq $-32, %rbx - LONG $0xe0c38348 // addq $-32, %rbx - LONG $0x05ebc148 // shrq $5, %rbx - WORD $0xff48; BYTE $0xc3 // incq %rbx - LONG $0xfce38348 // andq $-4, %rbx - WORD $0x3145; BYTE $0xc9 // xorl %r9d, %r9d - QUAD $0xfffff3ff056f0f66 // movdqa $-3073(%rip), %xmm0 /* LCPI36_0(%rip) */ - -LBB36_101: - LONG $0x0f348d4b // leaq (%r15,%r9), %rsi - LONG $0x447f0ff3; WORD $0x0131 // movdqu %xmm0, $1(%rcx,%rsi) - LONG $0x447f0ff3; WORD $0x1131 // movdqu %xmm0, $17(%rcx,%rsi) - LONG $0x447f0ff3; WORD $0x2131 // movdqu %xmm0, $33(%rcx,%rsi) - LONG $0x447f0ff3; WORD $0x3131 // movdqu %xmm0, $49(%rcx,%rsi) - LONG $0x447f0ff3; WORD $0x4131 // movdqu %xmm0, $65(%rcx,%rsi) - LONG $0x447f0ff3; WORD $0x5131 // movdqu %xmm0, $81(%rcx,%rsi) - LONG $0x447f0ff3; WORD $0x6131 // movdqu %xmm0, $97(%rcx,%rsi) - LONG $0x447f0ff3; WORD $0x7131 // movdqu %xmm0, $113(%rcx,%rsi) - LONG $0x80e98349 // subq $-128, %r9 - LONG $0xfcc38348 // addq $-4, %rbx - LONG $0xffbe850f; WORD $0xffff // jne LBB36_101, $-66(%rip) - -LBB36_102: - WORD $0x0148; BYTE $0xc8 // addq %rcx, %rax - LONG $0x03c0f641 // testb $3, %r8b - LONG $0x004b840f; WORD $0x0000 // je LBB36_105, $75(%rip) - WORD $0xfe41; BYTE $0xc6 // incb %r14b - LONG $0x60e68041 // andb $96, %r14b - LONG $0xe0c68041 // addb $-32, %r14b - LONG $0x05eec041 // shrb $5, %r14b - WORD $0xfe41; BYTE $0xc6 // incb %r14b - LONG $0xc6b60f45 // movzbl %r14b, %r8d - LONG $0x03e08341 // andl $3, %r8d - LONG $0x05e0c149 // shlq $5, %r8 - WORD $0x014d; BYTE $0xf9 // addq %r15, %r9 - LONG $0x11c18349 // addq $17, %r9 - WORD $0xdb31 // xorl %ebx, %ebx - QUAD $0xfffff381056f0f66 // movdqa $-3199(%rip), %xmm0 /* LCPI36_0(%rip) */ +LBB31_133: + WORD $0x894d; BYTE $0xc8 // movq %r9, %r8 + WORD $0x3949; BYTE $0xc3 // cmpq %rax, %r11 + LONG $0x001a840f; WORD $0x0000 // je LBB31_136, $26(%rip) -LBB36_104: - LONG $0x19348d49 // leaq (%r9,%rbx), %rsi - LONG $0x447f0ff3; WORD $0xf031 // movdqu %xmm0, $-16(%rcx,%rsi) - LONG $0x047f0ff3; BYTE $0x31 // movdqu %xmm0, (%rcx,%rsi) - LONG $0x20c38348 // addq $32, %rbx - WORD $0x3949; BYTE $0xd8 // cmpq %rbx, %r8 - LONG $0xffe4850f; WORD $0xffff // jne LBB36_104, $-28(%rip) +LBB31_134: + WORD $0x894d; BYTE $0xc8 // movq %r9, %r8 + LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 -LBB36_105: - WORD $0x3949; BYTE $0xd3 // cmpq %rdx, %r11 - LONG $0xfbff840f; WORD $0xffff // je LBB36_146, $-1025(%rip) - QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90 +LBB31_135: + LONG $0x3000c641 // movb $48, (%r8) + WORD $0xff49; BYTE $0xc0 // incq %r8 + WORD $0xc0ff // incl %eax + WORD $0x3944; BYTE $0xf0 // cmpl %r14d, %eax + LONG $0xffee8c0f; WORD $0xffff // jl LBB31_135, $-18(%rip) -LBB36_106: - WORD $0x00c6; BYTE $0x30 // movb $48, (%rax) - WORD $0xff48; BYTE $0xc0 // incq %rax - WORD $0xc2ff // incl %edx - WORD $0x3944; BYTE $0xd2 // cmpl %r10d, %edx - LONG $0xffef8c0f; WORD $0xffff // jl LBB36_106, $-17(%rip) - LONG $0xfffbdde9; BYTE $0xff // jmp LBB36_146, $-1059(%rip) - -LBB36_1: - WORD $0xc031 // xorl %eax, %eax - LONG $0xfffbd8e9; BYTE $0xff // jmp LBB36_147, $-1064(%rip) - -LBB36_5: - LONG $0xff6bb841; WORD $0xffff // movl $-149, %r8d - WORD $0x8941; BYTE $0xc7 // movl %eax, %r15d - LONG $0xfff3b7e9; BYTE $0xff // jmp LBB36_6, $-3145(%rip) - LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 +LBB31_136: + WORD $0x2941; BYTE $0xf8 // subl %edi, %r8d + +LBB31_137: + WORD $0x8944; BYTE $0xc0 // movl %r8d, %eax + BYTE $0x5b // popq %rbx + WORD $0x5c41 // popq %r12 + WORD $0x5d41 // popq %r13 + WORD $0x5e41 // popq %r14 + WORD $0x5f41 // popq %r15 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB31_138: + WORD $0x3145; BYTE $0xc0 // xorl %r8d, %r8d + LONG $0xffffeae9; BYTE $0xff // jmp LBB31_137, $-22(%rip) + +LBB31_139: + LONG $0xff6bbf41; WORD $0xffff // movl $-149, %r15d + WORD $0xc689 // movl %eax, %esi + LONG $0xfff3a5e9; BYTE $0xff // jmp LBB31_5, $-3163(%rip) + QUAD $0x9090909090909090 // .p2align 4, 0x90 _format_significand: BYTE $0x55 // pushq %rbp WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp WORD $0x5641 // pushq %r14 BYTE $0x53 // pushq %rbx - WORD $0x8941; BYTE $0xd0 // movl %edx, %r8d + WORD $0x634c; BYTE $0xc2 // movslq %edx, %r8 WORD $0x0149; BYTE $0xf0 // addq %rsi, %r8 WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax LONG $0x20e8c148 // shrq $32, %rax - LONG $0x001c850f; WORD $0x0000 // jne LBB37_2, $28(%rip) + LONG $0x001c850f; WORD $0x0000 // jne LBB32_2, $28(%rip) WORD $0x3145; BYTE $0xc9 // xorl %r9d, %r9d WORD $0x894d; BYTE $0xc6 // movq %r8, %r14 WORD $0x8948; BYTE $0xfa // movq %rdi, %rdx LONG $0x2710fa81; WORD $0x0000 // cmpl $10000, %edx - LONG $0x00e3830f; WORD $0x0000 // jae LBB37_8, $227(%rip) + LONG $0x00e3830f; WORD $0x0000 // jae LBB32_8, $227(%rip) -LBB37_7: +LBB32_7: WORD $0xd789 // movl %edx, %edi - LONG $0x000132e9; BYTE $0x00 // jmp LBB37_10, $306(%rip) + LONG $0x000132e9; BYTE $0x00 // jmp LBB32_10, $306(%rip) -LBB37_2: +LBB32_2: QUAD $0x77118461cefdb948; WORD $0xabcc // movabsq $-6067343680855748867, %rcx WORD $0x8948; BYTE $0xf8 // movq %rdi, %rax WORD $0xf748; BYTE $0xe1 // mulq %rcx LONG $0x1aeac148 // shrq $26, %rdx LONG $0x1f00ca69; WORD $0xfa0a // imull $-100000000, %edx, %ecx WORD $0xf901 // addl %edi, %ecx - LONG $0x00a4840f; WORD $0x0000 // je LBB37_3, $164(%rip) + LONG $0x00a4840f; WORD $0x0000 // je LBB32_3, $164(%rip) WORD $0xc889 // movl %ecx, %eax LONG $0x1759b941; WORD $0xd1b7 // movl $3518437209, %r9d LONG $0xc1af0f49 // imulq %r9, %rax @@ -9543,7 +10187,7 @@ LBB37_2: WORD $0xcf6b; BYTE $0x64 // imull $100, %edi, %ecx WORD $0xc829 // subl %ecx, %eax LONG $0xd8b70f44 // movzwl %ax, %r11d - LONG $0x330d8d48; WORD $0x0037; BYTE $0x00 // leaq $14131(%rip), %rcx /* _Digits(%rip) */ + LONG $0x230d8d48; WORD $0x0034; BYTE $0x00 // leaq $13347(%rip), %rcx /* _Digits(%rip) */ LONG $0x04b70f42; BYTE $0x51 // movzwl (%rcx,%r10,2), %eax LONG $0x40894166; BYTE $0xfe // movw %ax, $-2(%r8) LONG $0x04b70f42; BYTE $0x49 // movzwl (%rcx,%r9,2), %eax @@ -9555,21 +10199,21 @@ LBB37_2: WORD $0x3145; BYTE $0xc9 // xorl %r9d, %r9d LONG $0xf8708d4d // leaq $-8(%r8), %r14 LONG $0x2710fa81; WORD $0x0000 // cmpl $10000, %edx - LONG $0xff38820f; WORD $0xffff // jb LBB37_7, $-200(%rip) - LONG $0x000016e9; BYTE $0x00 // jmp LBB37_8, $22(%rip) + LONG $0xff38820f; WORD $0xffff // jb LBB32_7, $-200(%rip) + LONG $0x000016e9; BYTE $0x00 // jmp LBB32_8, $22(%rip) -LBB37_3: +LBB32_3: LONG $0x0008b941; WORD $0x0000 // movl $8, %r9d LONG $0xf8708d4d // leaq $-8(%r8), %r14 LONG $0x2710fa81; WORD $0x0000 // cmpl $10000, %edx - LONG $0xff1d820f; WORD $0xffff // jb LBB37_7, $-227(%rip) + LONG $0xff1d820f; WORD $0xffff // jb LBB32_7, $-227(%rip) -LBB37_8: +LBB32_8: LONG $0x1759ba41; WORD $0xd1b7 // movl $3518437209, %r10d - LONG $0xd11d8d4c; WORD $0x0036; BYTE $0x00 // leaq $14033(%rip), %r11 /* _Digits(%rip) */ + LONG $0xc11d8d4c; WORD $0x0033; BYTE $0x00 // leaq $13249(%rip), %r11 /* _Digits(%rip) */ BYTE $0x90 // .p2align 4, 0x90 -LBB37_9: +LBB32_9: WORD $0xd789 // movl %edx, %edi LONG $0xfaaf0f49 // imulq %r10, %rdi LONG $0x2defc148 // shrq $45, %rdi @@ -9586,22 +10230,22 @@ LBB37_9: LONG $0xfcc68349 // addq $-4, %r14 LONG $0xe0fffa81; WORD $0x05f5 // cmpl $99999999, %edx WORD $0xfa89 // movl %edi, %edx - LONG $0xffb8870f; WORD $0xffff // ja LBB37_9, $-72(%rip) + LONG $0xffb8870f; WORD $0xffff // ja LBB32_9, $-72(%rip) -LBB37_10: +LBB32_10: WORD $0xff83; BYTE $0x64 // cmpl $100, %edi - LONG $0x0020830f; WORD $0x0000 // jae LBB37_11, $32(%rip) + LONG $0x0020830f; WORD $0x0000 // jae LBB32_11, $32(%rip) WORD $0xff83; BYTE $0x0a // cmpl $10, %edi - LONG $0x004d820f; WORD $0x0000 // jb LBB37_14, $77(%rip) + LONG $0x004d820f; WORD $0x0000 // jb LBB32_14, $77(%rip) -LBB37_13: +LBB32_13: WORD $0xf889 // movl %edi, %eax - LONG $0x6d0d8d48; WORD $0x0036; BYTE $0x00 // leaq $13933(%rip), %rcx /* _Digits(%rip) */ + LONG $0x5d0d8d48; WORD $0x0033; BYTE $0x00 // leaq $13149(%rip), %rcx /* _Digits(%rip) */ LONG $0x4104b70f // movzwl (%rcx,%rax,2), %eax LONG $0x46894166; BYTE $0xfe // movw %ax, $-2(%r14) - LONG $0x00003de9; BYTE $0x00 // jmp LBB37_15, $61(%rip) + LONG $0x00003de9; BYTE $0x00 // jmp LBB32_15, $61(%rip) -LBB37_11: +LBB32_11: WORD $0xb70f; BYTE $0xc7 // movzwl %di, %eax WORD $0xe8c1; BYTE $0x02 // shrl $2, %eax LONG $0x147bc069; WORD $0x0000 // imull $5243, %eax, %eax @@ -9609,19 +10253,19 @@ LBB37_11: WORD $0xc86b; BYTE $0x64 // imull $100, %eax, %ecx WORD $0xcf29 // subl %ecx, %edi WORD $0xb70f; BYTE $0xcf // movzwl %di, %ecx - LONG $0x41158d48; WORD $0x0036; BYTE $0x00 // leaq $13889(%rip), %rdx /* _Digits(%rip) */ + LONG $0x31158d48; WORD $0x0033; BYTE $0x00 // leaq $13105(%rip), %rdx /* _Digits(%rip) */ LONG $0x4a0cb70f // movzwl (%rdx,%rcx,2), %ecx LONG $0x4e894166; BYTE $0xfe // movw %cx, $-2(%r14) LONG $0xfec68349 // addq $-2, %r14 WORD $0xc789 // movl %eax, %edi WORD $0xff83; BYTE $0x0a // cmpl $10, %edi - LONG $0xffb3830f; WORD $0xffff // jae LBB37_13, $-77(%rip) + LONG $0xffb3830f; WORD $0xffff // jae LBB32_13, $-77(%rip) -LBB37_14: +LBB32_14: LONG $0x30c78040 // addb $48, %dil WORD $0x8840; BYTE $0x3e // movb %dil, (%rsi) -LBB37_15: +LBB32_15: WORD $0x294d; BYTE $0xc8 // subq %r9, %r8 WORD $0x894c; BYTE $0xc0 // movq %r8, %rax BYTE $0x5b // popq %rbx @@ -9633,170 +10277,166 @@ LBB37_15: _left_shift: BYTE $0x55 // pushq %rbp WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp - WORD $0x5741 // pushq %r15 WORD $0x5641 // pushq %r14 BYTE $0x53 // pushq %rbx WORD $0xf189 // movl %esi, %ecx - LONG $0x68c16b48 // imulq $104, %rcx, %rax - LONG $0xea158d48; WORD $0x008f; BYTE $0x00 // leaq $36842(%rip), %rdx /* _LSHIFT_TAB(%rip) */ - LONG $0x10048b44 // movl (%rax,%rdx), %r8d - WORD $0x8b4c; BYTE $0x0f // movq (%rdi), %r9 - WORD $0x0148; BYTE $0xc2 // addq %rax, %rdx - LONG $0x04c28348 // addq $4, %rdx - LONG $0x10476348 // movslq $16(%rdi), %rax + LONG $0x68d16b48 // imulq $104, %rcx, %rdx + LONG $0xdc358d48; WORD $0x008c; BYTE $0x00 // leaq $36060(%rip), %rsi /* _LSHIFT_TAB(%rip) */ + LONG $0x32048b44 // movl (%rdx,%rsi), %r8d + WORD $0x8b4c; BYTE $0x17 // movq (%rdi), %r10 + LONG $0x104f634c // movslq $16(%rdi), %r9 + LONG $0x0432448a // movb $4(%rdx,%rsi), %al + WORD $0x854d; BYTE $0xc9 // testq %r9, %r9 + LONG $0x0036840f; WORD $0x0000 // je LBB33_6, $54(%rip) + LONG $0x32548d48; BYTE $0x05 // leaq $5(%rdx,%rsi), %rdx WORD $0xf631 // xorl %esi, %esi - WORD $0x8548; BYTE $0xc0 // testq %rax, %rax - LONG $0x0031840f; WORD $0x0000 // je LBB38_6, $49(%rip) QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90 -LBB38_1: - LONG $0x321cb60f // movzbl (%rdx,%rsi), %ebx - WORD $0xdb84 // testb %bl, %bl - LONG $0x0025840f; WORD $0x0000 // je LBB38_8, $37(%rip) - LONG $0x311c3841 // cmpb %bl, (%r9,%rsi) - LONG $0x0189850f; WORD $0x0000 // jne LBB38_3, $393(%rip) +LBB33_3: + WORD $0xc084 // testb %al, %al + LONG $0x0025840f; WORD $0x0000 // je LBB33_8, $37(%rip) + LONG $0x32043841 // cmpb %al, (%r10,%rsi) + LONG $0x0189850f; WORD $0x0000 // jne LBB33_5, $393(%rip) + LONG $0x3204b60f // movzbl (%rdx,%rsi), %eax WORD $0xff48; BYTE $0xc6 // incq %rsi - WORD $0x3948; BYTE $0xf0 // cmpq %rsi, %rax - LONG $0xffde850f; WORD $0xffff // jne LBB38_1, $-34(%rip) - WORD $0xc689 // movl %eax, %esi + WORD $0x3949; BYTE $0xf1 // cmpq %rsi, %r9 + LONG $0xffde850f; WORD $0xffff // jne LBB33_3, $-34(%rip) -LBB38_6: - LONG $0x00323c80 // cmpb $0, (%rdx,%rsi) - LONG $0x0003840f; WORD $0x0000 // je LBB38_8, $3(%rip) +LBB33_6: + WORD $0xc084 // testb %al, %al + LONG $0x0003840f; WORD $0x0000 // je LBB33_8, $3(%rip) -LBB38_7: +LBB33_7: WORD $0xff41; BYTE $0xc8 // decl %r8d -LBB38_8: - WORD $0xc085 // testl %eax, %eax - LONG $0x00968e0f; WORD $0x0000 // jle LBB38_22, $150(%rip) - LONG $0x001c8d45 // leal (%r8,%rax), %r11d - WORD $0xc389 // movl %eax, %ebx - WORD $0x634d; BYTE $0xf3 // movslq %r11d, %r14 - WORD $0xff49; BYTE $0xce // decq %r14 - WORD $0xff48; BYTE $0xc3 // incq %rbx - WORD $0xd231 // xorl %edx, %edx - QUAD $0xcccccccccccdba49; WORD $0xcccc // movabsq $-3689348814741910323, %r10 - LONG $0x000023e9; BYTE $0x00 // jmp LBB38_10, $35(%rip) - LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 - -LBB38_11: - WORD $0x3004 // addb $48, %al - LONG $0x31048843 // movb %al, (%r9,%r14) - WORD $0x8b4c; BYTE $0x0f // movq (%rdi), %r9 +LBB33_8: + WORD $0x8545; BYTE $0xc9 // testl %r9d, %r9d + LONG $0x008c8e0f; WORD $0x0000 // jle LBB33_23, $140(%rip) + LONG $0x08048d43 // leal (%r8,%r9), %eax + WORD $0x634c; BYTE $0xf0 // movslq %eax, %r14 + WORD $0xff49; BYTE $0xce // decq %r14 + WORD $0xd231 // xorl %edx, %edx + QUAD $0xcccccccccccdbb49; WORD $0xcccc // movabsq $-3689348814741910323, %r11 + LONG $0x90909090 // .p2align 4, 0x90 -LBB38_18: - WORD $0xff41; BYTE $0xcb // decl %r11d - WORD $0xff49; BYTE $0xce // decq %r14 - WORD $0xff48; BYTE $0xcb // decq %rbx - LONG $0x01fb8348 // cmpq $1, %rbx - LONG $0x0049860f; WORD $0x0000 // jbe LBB38_12, $73(%rip) +LBB33_10: + LONG $0x74be0f4b; WORD $0xff0a // movsbq $-1(%r10,%r9), %rsi + LONG $0xd0c68348 // addq $-48, %rsi + WORD $0xd348; BYTE $0xe6 // shlq %cl, %rsi + WORD $0x0148; BYTE $0xd6 // addq %rdx, %rsi + WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax + WORD $0xf749; BYTE $0xe3 // mulq %r11 + LONG $0x03eac148 // shrq $3, %rdx + LONG $0x12048d48 // leaq (%rdx,%rdx), %rax + LONG $0x801c8d48 // leaq (%rax,%rax,4), %rbx + WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax + WORD $0x2948; BYTE $0xd8 // subq %rbx, %rax + LONG $0x0877394c // cmpq %r14, $8(%rdi) + LONG $0x000e860f; WORD $0x0000 // jbe LBB33_16, $14(%rip) + WORD $0x3004 // addb $48, %al + LONG $0x32048843 // movb %al, (%r10,%r14) + LONG $0x000013e9; BYTE $0x00 // jmp LBB33_18, $19(%rip) + WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 -LBB38_10: - WORD $0x438d; BYTE $0xfe // leal $-2(%rbx), %eax - LONG $0x34be0f49; BYTE $0x01 // movsbq (%r9,%rax), %rsi - LONG $0xd0c68348 // addq $-48, %rsi - WORD $0xd348; BYTE $0xe6 // shlq %cl, %rsi - WORD $0x0148; BYTE $0xd6 // addq %rdx, %rsi - WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax - WORD $0xf749; BYTE $0xe2 // mulq %r10 - LONG $0x03eac148 // shrq $3, %rdx - LONG $0x12048d48 // leaq (%rdx,%rdx), %rax - LONG $0x803c8d4c // leaq (%rax,%rax,4), %r15 - WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax - WORD $0x294c; BYTE $0xf8 // subq %r15, %rax - LONG $0x0877394c // cmpq %r14, $8(%rdi) - LONG $0xffb0870f; WORD $0xffff // ja LBB38_11, $-80(%rip) +LBB33_16: WORD $0x8548; BYTE $0xc0 // testq %rax, %rax - LONG $0xffb0840f; WORD $0xffff // je LBB38_18, $-80(%rip) + LONG $0x0007840f; WORD $0x0000 // je LBB33_18, $7(%rip) LONG $0x011c47c7; WORD $0x0000; BYTE $0x00 // movl $1, $28(%rdi) - LONG $0xffffa4e9; BYTE $0xff // jmp LBB38_18, $-92(%rip) -LBB38_12: +LBB33_18: + LONG $0x02f98349 // cmpq $2, %r9 + LONG $0x000e8c0f; WORD $0x0000 // jl LBB33_12, $14(%rip) + WORD $0xff49; BYTE $0xc9 // decq %r9 + WORD $0x8b4c; BYTE $0x17 // movq (%rdi), %r10 + WORD $0xff49; BYTE $0xce // decq %r14 + LONG $0xffff98e9; BYTE $0xff // jmp LBB33_10, $-104(%rip) + +LBB33_12: LONG $0x0afe8348 // cmpq $10, %rsi - LONG $0x0070830f; WORD $0x0000 // jae LBB38_13, $112(%rip) + LONG $0x0067830f; WORD $0x0000 // jae LBB33_13, $103(%rip) -LBB38_22: - LONG $0x10476348 // movslq $16(%rdi), %rax - WORD $0x6349; BYTE $0xc8 // movslq %r8d, %rcx - WORD $0x0148; BYTE $0xc1 // addq %rax, %rcx - WORD $0x4f89; BYTE $0x10 // movl %ecx, $16(%rdi) - LONG $0x08478b48 // movq $8(%rdi), %rax - WORD $0x3948; BYTE $0xc8 // cmpq %rcx, %rax - LONG $0x0005870f; WORD $0x0000 // ja LBB38_24, $5(%rip) +LBB33_23: + LONG $0x104f6348 // movslq $16(%rdi), %rcx + WORD $0x6349; BYTE $0xc0 // movslq %r8d, %rax + WORD $0x0148; BYTE $0xc8 // addq %rcx, %rax WORD $0x4789; BYTE $0x10 // movl %eax, $16(%rdi) - WORD $0xc189 // movl %eax, %ecx - -LBB38_24: - LONG $0x14470144 // addl %r8d, $20(%rdi) - WORD $0xc985 // testl %ecx, %ecx - LONG $0x00318e0f; WORD $0x0000 // jle LBB38_28, $49(%rip) - WORD $0x8b48; BYTE $0x07 // movq (%rdi), %rax - WORD $0xc989 // movl %ecx, %ecx - BYTE $0x90 // .p2align 4, 0x90 - -LBB38_26: - LONG $0xff518d48 // leaq $-1(%rcx), %rdx - WORD $0xd689 // movl %edx, %esi - LONG $0x30303c80 // cmpb $48, (%rax,%rsi) - LONG $0x0028850f; WORD $0x0000 // jne LBB38_30, $40(%rip) - WORD $0xc9ff // decl %ecx + LONG $0x084f8b48 // movq $8(%rdi), %rcx + WORD $0x3948; BYTE $0xc1 // cmpq %rax, %rcx + LONG $0x0005870f; WORD $0x0000 // ja LBB33_25, $5(%rip) WORD $0x4f89; BYTE $0x10 // movl %ecx, $16(%rdi) - LONG $0x01728d48 // leaq $1(%rdx), %rsi - WORD $0x8948; BYTE $0xd1 // movq %rdx, %rcx - LONG $0x01fe8348 // cmpq $1, %rsi - LONG $0xffda870f; WORD $0xffff // ja LBB38_26, $-38(%rip) - LONG $0x000006e9; BYTE $0x00 // jmp LBB38_29, $6(%rip) + WORD $0xc889 // movl %ecx, %eax -LBB38_28: - LONG $0x0007850f; WORD $0x0000 // jne LBB38_30, $7(%rip) +LBB33_25: + LONG $0x14470144 // addl %r8d, $20(%rdi) + WORD $0xc085 // testl %eax, %eax + LONG $0x002f8e0f; WORD $0x0000 // jle LBB33_29, $47(%rip) + WORD $0x8b48; BYTE $0x0f // movq (%rdi), %rcx + WORD $0xc289 // movl %eax, %edx + WORD $0xff48; BYTE $0xc2 // incq %rdx + QUAD $0x9090909090909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 -LBB38_29: - LONG $0x001447c7; WORD $0x0000; BYTE $0x00 // movl $0, $20(%rdi) +LBB33_27: + WORD $0xc8ff // decl %eax + LONG $0x30013c80 // cmpb $48, (%rcx,%rax) + LONG $0x0018850f; WORD $0x0000 // jne LBB33_31, $24(%rip) + WORD $0x4789; BYTE $0x10 // movl %eax, $16(%rdi) + WORD $0xff48; BYTE $0xca // decq %rdx + LONG $0x01fa8348 // cmpq $1, %rdx + LONG $0xffe48f0f; WORD $0xffff // jg LBB33_27, $-28(%rip) -LBB38_30: +LBB33_29: + WORD $0xc085 // testl %eax, %eax + LONG $0x006b840f; WORD $0x0000 // je LBB33_30, $107(%rip) + +LBB33_31: BYTE $0x5b // popq %rbx WORD $0x5e41 // popq %r14 - WORD $0x5f41 // popq %r15 BYTE $0x5d // popq %rbp BYTE $0xc3 // retq -LBB38_13: - WORD $0x6349; BYTE $0xf3 // movslq %r11d, %rsi - WORD $0xff48; BYTE $0xce // decq %rsi - LONG $0x00001be9; BYTE $0x00 // jmp LBB38_14, $27(%rip) - LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 +LBB33_13: + WORD $0x6349; BYTE $0xf6 // movslq %r14d, %rsi + WORD $0xff48; BYTE $0xce // decq %rsi + LONG $0x000021e9; BYTE $0x00 // jmp LBB33_14, $33(%rip) + QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90 -LBB38_15: +LBB33_15: WORD $0x3004 // addb $48, %al WORD $0x8b48; BYTE $0x1f // movq (%rdi), %rbx WORD $0x0488; BYTE $0x33 // movb %al, (%rbx,%rsi) -LBB38_21: +LBB33_22: WORD $0xff48; BYTE $0xce // decq %rsi LONG $0x09f98348 // cmpq $9, %rcx - LONG $0xff6a860f; WORD $0xffff // jbe LBB38_22, $-150(%rip) + LONG $0xff6d860f; WORD $0xffff // jbe LBB33_23, $-147(%rip) -LBB38_14: +LBB33_14: WORD $0x8948; BYTE $0xd1 // movq %rdx, %rcx WORD $0x8948; BYTE $0xd0 // movq %rdx, %rax - WORD $0xf749; BYTE $0xe2 // mulq %r10 + WORD $0xf749; BYTE $0xe3 // mulq %r11 LONG $0x03eac148 // shrq $3, %rdx LONG $0x12048d48 // leaq (%rdx,%rdx), %rax LONG $0x801c8d48 // leaq (%rax,%rax,4), %rbx WORD $0x8948; BYTE $0xc8 // movq %rcx, %rax WORD $0x2948; BYTE $0xd8 // subq %rbx, %rax LONG $0x08773948 // cmpq %rsi, $8(%rdi) - LONG $0xffc6870f; WORD $0xffff // ja LBB38_15, $-58(%rip) + LONG $0xffc6870f; WORD $0xffff // ja LBB33_15, $-58(%rip) WORD $0x8548; BYTE $0xc0 // testq %rax, %rax - LONG $0xffc5840f; WORD $0xffff // je LBB38_21, $-59(%rip) + LONG $0xffc5840f; WORD $0xffff // je LBB33_22, $-59(%rip) LONG $0x011c47c7; WORD $0x0000; BYTE $0x00 // movl $1, $28(%rdi) - LONG $0xffffb9e9; BYTE $0xff // jmp LBB38_21, $-71(%rip) + LONG $0xffffb9e9; BYTE $0xff // jmp LBB33_22, $-71(%rip) -LBB38_3: - LONG $0xfe898c0f; WORD $0xffff // jl LBB38_7, $-375(%rip) - LONG $0xfffe87e9; BYTE $0xff // jmp LBB38_8, $-377(%rip) - LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 +LBB33_30: + LONG $0x001447c7; WORD $0x0000; BYTE $0x00 // movl $0, $20(%rdi) + BYTE $0x5b // popq %rbx + WORD $0x5e41 // popq %r14 + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + +LBB33_5: + LONG $0xfe898c0f; WORD $0xffff // jl LBB33_7, $-375(%rip) + LONG $0xfffe87e9; BYTE $0xff // jmp LBB33_8, $-377(%rip) + QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90 _right_shift: BYTE $0x55 // pushq %rbp @@ -9807,26 +10447,25 @@ _right_shift: WORD $0xd231 // xorl %edx, %edx WORD $0x8545; BYTE $0xc0 // testl %r8d, %r8d LONG $0x0000bb41; WORD $0x0000 // movl $0, %r11d - LONG $0xd84f0f45 // cmovgl %r8d, %r11d + LONG $0xd8490f45 // cmovnsl %r8d, %r11d WORD $0xc031 // xorl %eax, %eax LONG $0x90909090 // .p2align 4, 0x90 -LBB39_1: +LBB34_1: WORD $0x3949; BYTE $0xd3 // cmpq %rdx, %r11 - LONG $0x0132840f; WORD $0x0000 // je LBB39_2, $306(%rip) + LONG $0x0132840f; WORD $0x0000 // je LBB34_2, $306(%rip) LONG $0x80048d48 // leaq (%rax,%rax,4), %rax WORD $0x8b48; BYTE $0x37 // movq (%rdi), %rsi LONG $0x34be0f48; BYTE $0x16 // movsbq (%rsi,%rdx), %rsi - LONG $0x46048d48 // leaq (%rsi,%rax,2), %rax - LONG $0xd0c08348 // addq $-48, %rax + LONG $0x46448d48; BYTE $0xd0 // leaq $-48(%rsi,%rax,2), %rax WORD $0xff48; BYTE $0xc2 // incq %rdx WORD $0x8948; BYTE $0xc6 // movq %rax, %rsi WORD $0xd348; BYTE $0xee // shrq %cl, %rsi WORD $0x8548; BYTE $0xf6 // testq %rsi, %rsi - LONG $0xffd1840f; WORD $0xffff // je LBB39_1, $-47(%rip) + LONG $0xffd4840f; WORD $0xffff // je LBB34_1, $-44(%rip) WORD $0x8941; BYTE $0xd3 // movl %edx, %r11d -LBB39_7: +LBB34_7: WORD $0x578b; BYTE $0x14 // movl $20(%rdi), %edx WORD $0x2944; BYTE $0xda // subl %r11d, %edx WORD $0xc2ff // incl %edx @@ -9836,122 +10475,119 @@ LBB39_7: WORD $0xf749; BYTE $0xd1 // notq %r9 WORD $0x3145; BYTE $0xd2 // xorl %r10d, %r10d WORD $0x3945; BYTE $0xc3 // cmpl %r8d, %r11d - LONG $0x00718d0f; WORD $0x0000 // jge LBB39_10, $113(%rip) + LONG $0x00648d0f; WORD $0x0000 // jge LBB34_10, $100(%rip) WORD $0x634d; BYTE $0xc3 // movslq %r11d, %r8 WORD $0x8b48; BYTE $0x37 // movq (%rdi), %rsi WORD $0x3145; BYTE $0xd2 // xorl %r10d, %r10d - BYTE $0x90 // .p2align 4, 0x90 + LONG $0x90909090 // .p2align 4, 0x90 -LBB39_9: - WORD $0x8948; BYTE $0xc2 // movq %rax, %rdx - WORD $0xd348; BYTE $0xea // shrq %cl, %rdx - WORD $0x214c; BYTE $0xc8 // andq %r9, %rax - WORD $0xc280; BYTE $0x30 // addb $48, %dl - LONG $0x16148842 // movb %dl, (%rsi,%r10) - WORD $0x8b48; BYTE $0x37 // movq (%rdi), %rsi - LONG $0x06148d4a // leaq (%rsi,%r8), %rdx - LONG $0x1cbe0f4d; BYTE $0x12 // movsbq (%r10,%rdx), %r11 - LONG $0x105c8d4b; BYTE $0x01 // leaq $1(%r8,%r10), %rbx - WORD $0xff49; BYTE $0xc2 // incq %r10 - LONG $0x80048d48 // leaq (%rax,%rax,4), %rax - LONG $0x43048d49 // leaq (%r11,%rax,2), %rax - LONG $0xd0c08348 // addq $-48, %rax - LONG $0x10576348 // movslq $16(%rdi), %rdx - WORD $0x3948; BYTE $0xd3 // cmpq %rdx, %rbx - LONG $0xffc38c0f; WORD $0xffff // jl LBB39_9, $-61(%rip) - LONG $0x000025e9; BYTE $0x00 // jmp LBB39_10, $37(%rip) - QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90 +LBB34_9: + WORD $0x8948; BYTE $0xc2 // movq %rax, %rdx + WORD $0xd348; BYTE $0xea // shrq %cl, %rdx + WORD $0x214c; BYTE $0xc8 // andq %r9, %rax + WORD $0xc280; BYTE $0x30 // addb $48, %dl + LONG $0x16148842 // movb %dl, (%rsi,%r10) + WORD $0x8b48; BYTE $0x37 // movq (%rdi), %rsi + LONG $0x06148d4a // leaq (%rsi,%r8), %rdx + LONG $0x1cbe0f4d; BYTE $0x12 // movsbq (%r10,%rdx), %r11 + LONG $0x105c8d4b; BYTE $0x01 // leaq $1(%r8,%r10), %rbx + LONG $0x01528d4d // leaq $1(%r10), %r10 + LONG $0x80048d48 // leaq (%rax,%rax,4), %rax + LONG $0x43448d49; BYTE $0xd0 // leaq $-48(%r11,%rax,2), %rax + LONG $0x10576348 // movslq $16(%rdi), %rdx + WORD $0x3948; BYTE $0xd3 // cmpq %rdx, %rbx + LONG $0xffc58c0f; WORD $0xffff // jl LBB34_9, $-59(%rip) + LONG $0x000017e9; BYTE $0x00 // jmp LBB34_10, $23(%rip) -LBB39_12: + // .p2align 4, 0x90 +LBB34_12: LONG $0x30c68040 // addb $48, %sil WORD $0x8b48; BYTE $0x1f // movq (%rdi), %rbx LONG $0x13348840 // movb %sil, (%rbx,%rdx) WORD $0xc2ff // incl %edx WORD $0x8941; BYTE $0xd2 // movl %edx, %r10d -LBB39_15: +LBB34_15: WORD $0x0148; BYTE $0xc0 // addq %rax, %rax LONG $0x80048d48 // leaq (%rax,%rax,4), %rax -LBB39_10: +LBB34_10: WORD $0x8548; BYTE $0xc0 // testq %rax, %rax - LONG $0x002b840f; WORD $0x0000 // je LBB39_16, $43(%rip) + LONG $0x002b840f; WORD $0x0000 // je LBB34_16, $43(%rip) WORD $0x8948; BYTE $0xc6 // movq %rax, %rsi WORD $0xd348; BYTE $0xee // shrq %cl, %rsi WORD $0x214c; BYTE $0xc8 // andq %r9, %rax WORD $0x6349; BYTE $0xd2 // movslq %r10d, %rdx LONG $0x08573948 // cmpq %rdx, $8(%rdi) - LONG $0xffca870f; WORD $0xffff // ja LBB39_12, $-54(%rip) + LONG $0xffca870f; WORD $0xffff // ja LBB34_12, $-54(%rip) WORD $0x8548; BYTE $0xf6 // testq %rsi, %rsi - LONG $0xffd1840f; WORD $0xffff // je LBB39_15, $-47(%rip) + LONG $0xffd1840f; WORD $0xffff // je LBB34_15, $-47(%rip) LONG $0x011c47c7; WORD $0x0000; BYTE $0x00 // movl $1, $28(%rdi) - LONG $0xffffc5e9; BYTE $0xff // jmp LBB39_15, $-59(%rip) + LONG $0xffffc5e9; BYTE $0xff // jmp LBB34_15, $-59(%rip) + +LBB34_16: + LONG $0x10578944 // movl %r10d, $16(%rdi) + WORD $0x8545; BYTE $0xd2 // testl %r10d, %r10d + LONG $0x00378e0f; WORD $0x0000 // jle LBB34_20, $55(%rip) + WORD $0x8b48; BYTE $0x07 // movq (%rdi), %rax + WORD $0x8944; BYTE $0xd1 // movl %r10d, %ecx + WORD $0xff48; BYTE $0xc1 // incq %rcx + QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90 -LBB39_16: +LBB34_18: + WORD $0xff41; BYTE $0xca // decl %r10d + LONG $0x103c8042; BYTE $0x30 // cmpb $48, (%rax,%r10) + LONG $0x001a850f; WORD $0x0000 // jne LBB34_22, $26(%rip) LONG $0x10578944 // movl %r10d, $16(%rdi) + WORD $0xff48; BYTE $0xc9 // decq %rcx + LONG $0x01f98348 // cmpq $1, %rcx + LONG $0xffe18f0f; WORD $0xffff // jg LBB34_18, $-31(%rip) + +LBB34_20: WORD $0x8545; BYTE $0xd2 // testl %r10d, %r10d - LONG $0x00758e0f; WORD $0x0000 // jle LBB39_20, $117(%rip) - WORD $0x8b48; BYTE $0x07 // movq (%rdi), %rax - WORD $0x8944; BYTE $0xd1 // movl %r10d, %ecx - WORD $0x9090 // .p2align 4, 0x90 + LONG $0x0045840f; WORD $0x0000 // je LBB34_21, $69(%rip) -LBB39_18: - LONG $0xff518d48 // leaq $-1(%rcx), %rdx - WORD $0xd689 // movl %edx, %esi - LONG $0x30303c80 // cmpb $48, (%rax,%rsi) - LONG $0x0063850f; WORD $0x0000 // jne LBB39_22, $99(%rip) - WORD $0xc9ff // decl %ecx - WORD $0x4f89; BYTE $0x10 // movl %ecx, $16(%rdi) - LONG $0x01728d48 // leaq $1(%rdx), %rsi - WORD $0x8948; BYTE $0xd1 // movq %rdx, %rcx - LONG $0x01fe8348 // cmpq $1, %rsi - LONG $0xffda870f; WORD $0xffff // ja LBB39_18, $-38(%rip) - LONG $0x00004be9; BYTE $0x00 // jmp LBB39_21, $75(%rip) +LBB34_22: + BYTE $0x5b // popq %rbx + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq -LBB39_2: +LBB34_2: WORD $0x8548; BYTE $0xc0 // testq %rax, %rax - LONG $0x004c840f; WORD $0x0000 // je LBB39_23, $76(%rip) + LONG $0x0043840f; WORD $0x0000 // je LBB34_23, $67(%rip) QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90 WORD $0x8948; BYTE $0xc2 // movq %rax, %rdx WORD $0xd348; BYTE $0xea // shrq %cl, %rdx WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx - LONG $0xfed3850f; WORD $0xffff // jne LBB39_7, $-301(%rip) + LONG $0xfed0850f; WORD $0xffff // jne LBB34_7, $-304(%rip) -LBB39_4: +LBB34_4: WORD $0x0148; BYTE $0xc0 // addq %rax, %rax LONG $0x80048d48 // leaq (%rax,%rax,4), %rax WORD $0xff41; BYTE $0xc3 // incl %r11d WORD $0x8948; BYTE $0xc2 // movq %rax, %rdx WORD $0xd348; BYTE $0xea // shrq %cl, %rdx WORD $0x8548; BYTE $0xd2 // testq %rdx, %rdx - LONG $0xffe7840f; WORD $0xffff // je LBB39_4, $-25(%rip) - LONG $0xfffeb5e9; BYTE $0xff // jmp LBB39_7, $-331(%rip) - -LBB39_20: - LONG $0x0003840f; WORD $0x0000 // je LBB39_21, $3(%rip) + LONG $0xffe7840f; WORD $0xffff // je LBB34_4, $-25(%rip) + LONG $0xfffeb2e9; BYTE $0xff // jmp LBB34_7, $-334(%rip) -LBB39_22: - BYTE $0x5b // popq %rbx - BYTE $0x5d // popq %rbp - BYTE $0xc3 // retq - -LBB39_21: +LBB34_21: LONG $0x001447c7; WORD $0x0000; BYTE $0x00 // movl $0, $20(%rdi) BYTE $0x5b // popq %rbx BYTE $0x5d // popq %rbp BYTE $0xc3 // retq -LBB39_23: - LONG $0x001047c7; WORD $0x0000; BYTE $0x00 // movl $0, $16(%rdi) - BYTE $0x5b // popq %rbx - BYTE $0x5d // popq %rbp - BYTE $0xc3 // retq - LONG $0x00000000; WORD $0x0000 // .p2align 4, 0x00 +LBB34_23: + LONG $0x001047c7; WORD $0x0000; BYTE $0x00 // movl $0, $16(%rdi) + BYTE $0x5b // popq %rbx + BYTE $0x5d // popq %rbp + BYTE $0xc3 // retq + QUAD $0x0000000000000000; LONG $0x00000000; WORD $0x0000; BYTE $0x00 // .p2align 4, 0x00 -LCPI40_0: +LCPI35_0: QUAD $0x2222222222222222; QUAD $0x2222222222222222 // .space 16, '""""""""""""""""' -LCPI40_1: +LCPI35_1: QUAD $0x5c5c5c5c5c5c5c5c; QUAD $0x5c5c5c5c5c5c5c5c // .space 16, '\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' // .p2align 4, 0x90 @@ -9966,107 +10602,110 @@ _advance_string_default: BYTE $0x50 // pushq %rax LONG $0x087f8b4c // movq $8(%rdi), %r15 WORD $0x2949; BYTE $0xf7 // subq %rsi, %r15 - LONG $0x037d840f; WORD $0x0000 // je LBB40_17, $893(%rip) - WORD $0x8b4c; BYTE $0x0f // movq (%rdi), %r9 + LONG $0x033f840f; WORD $0x0000 // je LBB35_13, $831(%rip) + WORD $0x8b4c; BYTE $0x1f // movq (%rdi), %r11 + WORD $0x014c; BYTE $0xde // addq %r11, %rsi LONG $0xff02c748; WORD $0xffff; BYTE $0xff // movq $-1, (%rdx) LONG $0x40ff8349 // cmpq $64, %r15 - LONG $0x01f7820f; WORD $0x0000 // jb LBB40_18, $503(%rip) - WORD $0x8948; BYTE $0xf7 // movq %rsi, %rdi - WORD $0xf748; BYTE $0xd7 // notq %rdi + LONG $0x0173820f; WORD $0x0000 // jb LBB35_14, $371(%rip) QUAD $0xffffffffd045c748 // movq $-1, $-48(%rbp) WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d - QUAD $0xffffff98056f0f66 // movdqa $-104(%rip), %xmm0 /* LCPI40_0(%rip) */ - QUAD $0xffffffa00d6f0f66 // movdqa $-96(%rip), %xmm1 /* LCPI40_1(%rip) */ + QUAD $0xffffff9b056f0f66 // movdqa $-101(%rip), %xmm0 /* LCPI35_0(%rip) */ + QUAD $0xffffffa30d6f0f66 // movdqa $-93(%rip), %xmm1 /* LCPI35_1(%rip) */ + QUAD $0x555555555555ba49; WORD $0x5555 // movabsq $6148914691236517205, %r10 + QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90 - // .p2align 4, 0x90 -LBB40_3: - LONG $0x6f0f41f3; WORD $0x3114 // movdqu (%r9,%rsi), %xmm2 - LONG $0x6f0f41f3; WORD $0x315c; BYTE $0x10 // movdqu $16(%r9,%rsi), %xmm3 - LONG $0x6f0f41f3; WORD $0x3164; BYTE $0x20 // movdqu $32(%r9,%rsi), %xmm4 - LONG $0x6f0f41f3; WORD $0x316c; BYTE $0x30 // movdqu $48(%r9,%rsi), %xmm5 - LONG $0xf26f0f66 // movdqa %xmm2, %xmm6 - LONG $0xf0740f66 // pcmpeqb %xmm0, %xmm6 - LONG $0xd70f4466; BYTE $0xe6 // pmovmskb %xmm6, %r12d - LONG $0xf36f0f66 // movdqa %xmm3, %xmm6 - LONG $0xf0740f66 // pcmpeqb %xmm0, %xmm6 - LONG $0xded70f66 // pmovmskb %xmm6, %ebx - LONG $0xf46f0f66 // movdqa %xmm4, %xmm6 - LONG $0xf0740f66 // pcmpeqb %xmm0, %xmm6 - LONG $0xd70f4466; BYTE $0xc6 // pmovmskb %xmm6, %r8d - LONG $0xf56f0f66 // movdqa %xmm5, %xmm6 - LONG $0xf0740f66 // pcmpeqb %xmm0, %xmm6 - LONG $0xd70f4466; BYTE $0xd6 // pmovmskb %xmm6, %r10d - LONG $0xd1740f66 // pcmpeqb %xmm1, %xmm2 - LONG $0xd70f4466; BYTE $0xea // pmovmskb %xmm2, %r13d - LONG $0xd9740f66 // pcmpeqb %xmm1, %xmm3 - LONG $0xcbd70f66 // pmovmskb %xmm3, %ecx - LONG $0xe1740f66 // pcmpeqb %xmm1, %xmm4 - LONG $0xc4d70f66 // pmovmskb %xmm4, %eax - LONG $0xe9740f66 // pcmpeqb %xmm1, %xmm5 - LONG $0xd70f4466; BYTE $0xdd // pmovmskb %xmm5, %r11d - LONG $0x30e2c149 // shlq $48, %r10 - LONG $0x20e0c149 // shlq $32, %r8 - WORD $0x094d; BYTE $0xd0 // orq %r10, %r8 - LONG $0x10e3c148 // shlq $16, %rbx - WORD $0x094c; BYTE $0xc3 // orq %r8, %rbx - WORD $0x0949; BYTE $0xdc // orq %rbx, %r12 - LONG $0x30e3c149 // shlq $48, %r11 - LONG $0x20e0c148 // shlq $32, %rax - WORD $0x094c; BYTE $0xd8 // orq %r11, %rax - LONG $0x10e1c148 // shlq $16, %rcx - WORD $0x0948; BYTE $0xc1 // orq %rax, %rcx - WORD $0x0949; BYTE $0xcd // orq %rcx, %r13 - LONG $0x0030850f; WORD $0x0000 // jne LBB40_7, $48(%rip) - WORD $0x854d; BYTE $0xf6 // testq %r14, %r14 - LONG $0x0040850f; WORD $0x0000 // jne LBB40_9, $64(%rip) - WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d - WORD $0x854d; BYTE $0xe4 // testq %r12, %r12 - LONG $0x0086850f; WORD $0x0000 // jne LBB40_10, $134(%rip) +LBB35_3: + LONG $0x166f0ff3 // movdqu (%rsi), %xmm2 + LONG $0x5e6f0ff3; BYTE $0x10 // movdqu $16(%rsi), %xmm3 + LONG $0x666f0ff3; BYTE $0x20 // movdqu $32(%rsi), %xmm4 + LONG $0x6e6f0ff3; BYTE $0x30 // movdqu $48(%rsi), %xmm5 + LONG $0xf26f0f66 // movdqa %xmm2, %xmm6 + LONG $0xf0740f66 // pcmpeqb %xmm0, %xmm6 + LONG $0xd70f4466; BYTE $0xe6 // pmovmskb %xmm6, %r12d + LONG $0xf36f0f66 // movdqa %xmm3, %xmm6 + LONG $0xf0740f66 // pcmpeqb %xmm0, %xmm6 + LONG $0xfed70f66 // pmovmskb %xmm6, %edi + LONG $0xf46f0f66 // movdqa %xmm4, %xmm6 + LONG $0xf0740f66 // pcmpeqb %xmm0, %xmm6 + LONG $0xc6d70f66 // pmovmskb %xmm6, %eax + LONG $0xf56f0f66 // movdqa %xmm5, %xmm6 + LONG $0xf0740f66 // pcmpeqb %xmm0, %xmm6 + LONG $0xd70f4466; BYTE $0xc6 // pmovmskb %xmm6, %r8d + LONG $0xd1740f66 // pcmpeqb %xmm1, %xmm2 + LONG $0xdad70f66 // pmovmskb %xmm2, %ebx + LONG $0xd9740f66 // pcmpeqb %xmm1, %xmm3 + LONG $0xd70f4466; BYTE $0xeb // pmovmskb %xmm3, %r13d + LONG $0xe1740f66 // pcmpeqb %xmm1, %xmm4 + LONG $0xccd70f66 // pmovmskb %xmm4, %ecx + LONG $0xe9740f66 // pcmpeqb %xmm1, %xmm5 + LONG $0xd70f4466; BYTE $0xcd // pmovmskb %xmm5, %r9d + LONG $0x30e0c149 // shlq $48, %r8 + LONG $0x20e0c148 // shlq $32, %rax + LONG $0x10e7c148 // shlq $16, %rdi + WORD $0x0949; BYTE $0xfc // orq %rdi, %r12 + WORD $0x0949; BYTE $0xc4 // orq %rax, %r12 + WORD $0x094d; BYTE $0xc4 // orq %r8, %r12 + LONG $0x30e1c149 // shlq $48, %r9 + LONG $0x20e1c148 // shlq $32, %rcx + LONG $0x10e5c149 // shlq $16, %r13 + WORD $0x094c; BYTE $0xeb // orq %r13, %rbx + WORD $0x0948; BYTE $0xcb // orq %rcx, %rbx + WORD $0x094c; BYTE $0xcb // orq %r9, %rbx + LONG $0x002c850f; WORD $0x0000 // jne LBB35_7, $44(%rip) + WORD $0x854d; BYTE $0xf6 // testq %r14, %r14 + LONG $0x0042850f; WORD $0x0000 // jne LBB35_9, $66(%rip) + WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d + WORD $0x854d; BYTE $0xe4 // testq %r12, %r12 + LONG $0x007e850f; WORD $0x0000 // jne LBB35_10, $126(%rip) -LBB40_6: - LONG $0xc0c78349 // addq $-64, %r15 - LONG $0xc0c78348 // addq $-64, %rdi +LBB35_6: LONG $0x40c68348 // addq $64, %rsi + LONG $0xc0c78349 // addq $-64, %r15 LONG $0x3fff8349 // cmpq $63, %r15 - LONG $0xff35870f; WORD $0xffff // ja LBB40_3, $-203(%rip) - LONG $0x000081e9; BYTE $0x00 // jmp LBB40_12, $129(%rip) + LONG $0xff42870f; WORD $0xffff // ja LBB35_3, $-190(%rip) + LONG $0x00008de9; BYTE $0x00 // jmp LBB35_15, $141(%rip) -LBB40_7: +LBB35_7: LONG $0xd07d8348; BYTE $0xff // cmpq $-1, $-48(%rbp) - LONG $0x000e850f; WORD $0x0000 // jne LBB40_9, $14(%rip) - LONG $0xc5bc0f49 // bsfq %r13, %rax - WORD $0x0148; BYTE $0xf0 // addq %rsi, %rax - LONG $0xd0458948 // movq %rax, $-48(%rbp) - WORD $0x8948; BYTE $0x02 // movq %rax, (%rdx) + LONG $0x0014850f; WORD $0x0000 // jne LBB35_9, $20(%rip) + WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax + WORD $0x294c; BYTE $0xd8 // subq %r11, %rax + LONG $0xcbbc0f48 // bsfq %rbx, %rcx + WORD $0x0148; BYTE $0xc1 // addq %rax, %rcx + LONG $0xd04d8948 // movq %rcx, $-48(%rbp) + WORD $0x8948; BYTE $0x0a // movq %rcx, (%rdx) -LBB40_9: +LBB35_9: WORD $0x894c; BYTE $0xf0 // movq %r14, %rax WORD $0xf748; BYTE $0xd0 // notq %rax - WORD $0x214c; BYTE $0xe8 // andq %r13, %rax - LONG $0x00048d4c // leaq (%rax,%rax), %r8 - WORD $0x094d; BYTE $0xf0 // orq %r14, %r8 - WORD $0x894c; BYTE $0xc1 // movq %r8, %rcx - WORD $0xf748; BYTE $0xd1 // notq %rcx - WORD $0x214c; BYTE $0xe9 // andq %r13, %rcx + WORD $0x2148; BYTE $0xd8 // andq %rbx, %rax + LONG $0x000c8d48 // leaq (%rax,%rax), %rcx + WORD $0x094c; BYTE $0xf1 // orq %r14, %rcx + WORD $0x8948; BYTE $0xcf // movq %rcx, %rdi + WORD $0xf748; BYTE $0xd7 // notq %rdi + WORD $0x2148; BYTE $0xdf // andq %rbx, %rdi QUAD $0xaaaaaaaaaaaabb48; WORD $0xaaaa // movabsq $-6148914691236517206, %rbx - WORD $0x2148; BYTE $0xd9 // andq %rbx, %rcx + WORD $0x2148; BYTE $0xdf // andq %rbx, %rdi WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d - WORD $0x0148; BYTE $0xc1 // addq %rax, %rcx + WORD $0x0148; BYTE $0xc7 // addq %rax, %rdi LONG $0xc6920f41 // setb %r14b - WORD $0x0148; BYTE $0xc9 // addq %rcx, %rcx - QUAD $0x555555555555b848; WORD $0x5555 // movabsq $6148914691236517205, %rax - WORD $0x3148; BYTE $0xc1 // xorq %rax, %rcx - WORD $0x214c; BYTE $0xc1 // andq %r8, %rcx - WORD $0xf748; BYTE $0xd1 // notq %rcx - WORD $0x2149; BYTE $0xcc // andq %rcx, %r12 + WORD $0x0148; BYTE $0xff // addq %rdi, %rdi + WORD $0x314c; BYTE $0xd7 // xorq %r10, %rdi + WORD $0x2148; BYTE $0xcf // andq %rcx, %rdi + WORD $0xf748; BYTE $0xd7 // notq %rdi + WORD $0x2149; BYTE $0xfc // andq %rdi, %r12 WORD $0x854d; BYTE $0xe4 // testq %r12, %r12 - LONG $0xff7a840f; WORD $0xffff // je LBB40_6, $-134(%rip) + LONG $0xff82840f; WORD $0xffff // je LBB35_6, $-126(%rip) -LBB40_10: - LONG $0xc4bc0f49 // bsfq %r12, %rax - WORD $0x2948; BYTE $0xf8 // subq %rdi, %rax +LBB35_10: + LONG $0xc4bc0f49 // bsfq %r12, %rax -LBB40_11: +LBB35_11: + WORD $0x294c; BYTE $0xde // subq %r11, %rsi + LONG $0x06448d48; BYTE $0x01 // leaq $1(%rsi,%rax), %rax + +LBB35_12: LONG $0x08c48348 // addq $8, %rsp BYTE $0x5b // popq %rbx WORD $0x5c41 // popq %r12 @@ -10076,384 +10715,145 @@ LBB40_11: BYTE $0x5d // popq %rbp BYTE $0xc3 // retq -LBB40_12: - WORD $0x014c; BYTE $0xce // addq %r9, %rsi - LONG $0x20ff8349 // cmpq $32, %r15 - LONG $0x00f5820f; WORD $0x0000 // jb LBB40_23, $245(%rip) +LBB35_14: + QUAD $0xffffffffd045c748 // movq $-1, $-48(%rbp) + WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d -LBB40_13: +LBB35_15: + LONG $0x20ff8349 // cmpq $32, %r15 + LONG $0x00cf820f; WORD $0x0000 // jb LBB35_24, $207(%rip) LONG $0x066f0ff3 // movdqu (%rsi), %xmm0 LONG $0x4e6f0ff3; BYTE $0x10 // movdqu $16(%rsi), %xmm1 - QUAD $0xfffffe21156f0f66 // movdqa $-479(%rip), %xmm2 /* LCPI40_0(%rip) */ - QUAD $0xfffffe291d6f0f66 // movdqa $-471(%rip), %xmm3 /* LCPI40_1(%rip) */ + QUAD $0xfffffe15156f0f66 // movdqa $-491(%rip), %xmm2 /* LCPI35_0(%rip) */ + QUAD $0xfffffe1d1d6f0f66 // movdqa $-483(%rip), %xmm3 /* LCPI35_1(%rip) */ LONG $0xe06f0f66 // movdqa %xmm0, %xmm4 LONG $0xe2740f66 // pcmpeqb %xmm2, %xmm4 LONG $0xfcd70f66 // pmovmskb %xmm4, %edi LONG $0xd1740f66 // pcmpeqb %xmm1, %xmm2 - LONG $0xcad70f66 // pmovmskb %xmm2, %ecx + LONG $0xc2d70f66 // pmovmskb %xmm2, %eax LONG $0xc3740f66 // pcmpeqb %xmm3, %xmm0 - LONG $0xc0d70f66 // pmovmskb %xmm0, %eax + LONG $0xd8d70f66 // pmovmskb %xmm0, %ebx LONG $0xcb740f66 // pcmpeqb %xmm3, %xmm1 - LONG $0xd9d70f66 // pmovmskb %xmm1, %ebx + LONG $0xc9d70f66 // pmovmskb %xmm1, %ecx + LONG $0x10e0c148 // shlq $16, %rax + WORD $0x0948; BYTE $0xc7 // orq %rax, %rdi LONG $0x10e1c148 // shlq $16, %rcx - WORD $0x0948; BYTE $0xcf // orq %rcx, %rdi - LONG $0x10e3c148 // shlq $16, %rbx - WORD $0x0948; BYTE $0xd8 // orq %rbx, %rax - LONG $0x0044850f; WORD $0x0000 // jne LBB40_19, $68(%rip) + WORD $0x0948; BYTE $0xcb // orq %rcx, %rbx + LONG $0x001e850f; WORD $0x0000 // jne LBB35_20, $30(%rip) WORD $0x854d; BYTE $0xf6 // testq %r14, %r14 - LONG $0x005a850f; WORD $0x0000 // jne LBB40_21, $90(%rip) + LONG $0x0034850f; WORD $0x0000 // jne LBB35_22, $52(%rip) WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d WORD $0x8548; BYTE $0xff // testq %rdi, %rdi - LONG $0x0087840f; WORD $0x0000 // je LBB40_22, $135(%rip) + LONG $0x0061840f; WORD $0x0000 // je LBB35_23, $97(%rip) -LBB40_16: +LBB35_19: LONG $0xc7bc0f48 // bsfq %rdi, %rax - WORD $0x294c; BYTE $0xce // subq %r9, %rsi - WORD $0x0148; BYTE $0xf0 // addq %rsi, %rax - WORD $0xff48; BYTE $0xc0 // incq %rax - LONG $0xffff6ce9; BYTE $0xff // jmp LBB40_11, $-148(%rip) + LONG $0xffff65e9; BYTE $0xff // jmp LBB35_11, $-155(%rip) -LBB40_18: - WORD $0x014c; BYTE $0xce // addq %r9, %rsi - QUAD $0xffffffffd045c748 // movq $-1, $-48(%rbp) - WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d - LONG $0x20ff8349 // cmpq $32, %r15 - LONG $0xff70830f; WORD $0xffff // jae LBB40_13, $-144(%rip) - LONG $0x000060e9; BYTE $0x00 // jmp LBB40_23, $96(%rip) - -LBB40_19: +LBB35_20: LONG $0xd07d8348; BYTE $0xff // cmpq $-1, $-48(%rbp) - LONG $0x0014850f; WORD $0x0000 // jne LBB40_21, $20(%rip) - WORD $0x8948; BYTE $0xf1 // movq %rsi, %rcx - WORD $0x294c; BYTE $0xc9 // subq %r9, %rcx - LONG $0xd8bc0f48 // bsfq %rax, %rbx - WORD $0x0148; BYTE $0xcb // addq %rcx, %rbx - LONG $0xd05d8948 // movq %rbx, $-48(%rbp) - WORD $0x8948; BYTE $0x1a // movq %rbx, (%rdx) + LONG $0x0014850f; WORD $0x0000 // jne LBB35_22, $20(%rip) + WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax + WORD $0x294c; BYTE $0xd8 // subq %r11, %rax + LONG $0xcbbc0f48 // bsfq %rbx, %rcx + WORD $0x0148; BYTE $0xc1 // addq %rax, %rcx + LONG $0xd04d8948 // movq %rcx, $-48(%rbp) + WORD $0x8948; BYTE $0x0a // movq %rcx, (%rdx) -LBB40_21: - WORD $0x8944; BYTE $0xf1 // movl %r14d, %ecx +LBB35_22: + WORD $0x8944; BYTE $0xf0 // movl %r14d, %eax + WORD $0xd0f7 // notl %eax + WORD $0xd821 // andl %ebx, %eax + LONG $0x46048d45 // leal (%r14,%rax,2), %r8d + WORD $0x0c8d; BYTE $0x00 // leal (%rax,%rax), %ecx WORD $0xd1f7 // notl %ecx - WORD $0xc121 // andl %eax, %ecx - WORD $0x1c8d; BYTE $0x09 // leal (%rcx,%rcx), %ebx - LONG $0x4e048d45 // leal (%r14,%rcx,2), %r8d - WORD $0xd3f7 // notl %ebx - WORD $0xc321 // andl %eax, %ebx - LONG $0xaaaae381; WORD $0xaaaa // andl $-1431655766, %ebx + WORD $0xd921 // andl %ebx, %ecx + LONG $0xaaaae181; WORD $0xaaaa // andl $-1431655766, %ecx WORD $0x3145; BYTE $0xf6 // xorl %r14d, %r14d - WORD $0xcb01 // addl %ecx, %ebx + WORD $0xc101 // addl %eax, %ecx LONG $0xc6920f41 // setb %r14b - WORD $0xdb01 // addl %ebx, %ebx - LONG $0x5555f381; WORD $0x5555 // xorl $1431655765, %ebx - WORD $0x2144; BYTE $0xc3 // andl %r8d, %ebx - WORD $0xd3f7 // notl %ebx - WORD $0xdf21 // andl %ebx, %edi + WORD $0xc901 // addl %ecx, %ecx + LONG $0x5555f181; WORD $0x5555 // xorl $1431655765, %ecx + WORD $0x2144; BYTE $0xc1 // andl %r8d, %ecx + WORD $0xd1f7 // notl %ecx + WORD $0xcf21 // andl %ecx, %edi WORD $0x8548; BYTE $0xff // testq %rdi, %rdi - LONG $0xff79850f; WORD $0xffff // jne LBB40_16, $-135(%rip) + LONG $0xff9f850f; WORD $0xffff // jne LBB35_19, $-97(%rip) -LBB40_22: +LBB35_23: LONG $0x20c68348 // addq $32, %rsi LONG $0xe0c78349 // addq $-32, %r15 -LBB40_23: - WORD $0x854d; BYTE $0xf6 // testq %r14, %r14 - LONG $0x00b4850f; WORD $0x0000 // jne LBB40_38, $180(%rip) - WORD $0x854d; BYTE $0xff // testq %r15, %r15 - LONG $0x0088840f; WORD $0x0000 // je LBB40_35, $136(%rip) - -LBB40_25: - WORD $0x894c; BYTE $0xcf // movq %r9, %rdi - WORD $0xf748; BYTE $0xdf // negq %rdi +LBB35_24: + WORD $0x854d; BYTE $0xf6 // testq %r14, %r14 + LONG $0x0089850f; WORD $0x0000 // jne LBB35_35, $137(%rip) LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax + WORD $0x854d; BYTE $0xff // testq %r15, %r15 + LONG $0xfef4840f; WORD $0xffff // je LBB35_12, $-268(%rip) -LBB40_26: - WORD $0xdb31 // xorl %ebx, %ebx +LBB35_26: + WORD $0x894d; BYTE $0xd9 // movq %r11, %r9 + WORD $0xf749; BYTE $0xd1 // notq %r9 + +LBB35_27: + LONG $0x014e8d48 // leaq $1(%rsi), %rcx + WORD $0xb60f; BYTE $0x1e // movzbl (%rsi), %ebx + WORD $0xfb80; BYTE $0x22 // cmpb $34, %bl + LONG $0x0058840f; WORD $0x0000 // je LBB35_34, $88(%rip) + LONG $0xff7f8d49 // leaq $-1(%r15), %rdi + WORD $0xfb80; BYTE $0x5c // cmpb $92, %bl + LONG $0x0014840f; WORD $0x0000 // je LBB35_30, $20(%rip) + WORD $0x8949; BYTE $0xff // movq %rdi, %r15 + WORD $0x8948; BYTE $0xce // movq %rcx, %rsi + WORD $0x8548; BYTE $0xff // testq %rdi, %rdi + LONG $0xffd4850f; WORD $0xffff // jne LBB35_27, $-44(%rip) + LONG $0xfffebde9; BYTE $0xff // jmp LBB35_12, $-323(%rip) -LBB40_27: - LONG $0x1e0cb60f // movzbl (%rsi,%rbx), %ecx - WORD $0xf983; BYTE $0x22 // cmpl $34, %ecx - LONG $0x0066840f; WORD $0x0000 // je LBB40_34, $102(%rip) - WORD $0xf983; BYTE $0x5c // cmpl $92, %ecx - LONG $0x0011840f; WORD $0x0000 // je LBB40_30, $17(%rip) - WORD $0xff48; BYTE $0xc3 // incq %rbx - WORD $0x3949; BYTE $0xdf // cmpq %rbx, %r15 - LONG $0xffde850f; WORD $0xffff // jne LBB40_27, $-34(%rip) - LONG $0x00005de9; BYTE $0x00 // jmp LBB40_36, $93(%rip) - -LBB40_30: - LONG $0xff4f8d49 // leaq $-1(%r15), %rcx - WORD $0x3948; BYTE $0xd9 // cmpq %rbx, %rcx - LONG $0xfe9a840f; WORD $0xffff // je LBB40_11, $-358(%rip) +LBB35_30: + WORD $0x8548; BYTE $0xff // testq %rdi, %rdi + LONG $0xfeb4840f; WORD $0xffff // je LBB35_12, $-332(%rip) LONG $0xd07d8348; BYTE $0xff // cmpq $-1, $-48(%rbp) - LONG $0x000e850f; WORD $0x0000 // jne LBB40_33, $14(%rip) - LONG $0x370c8d48 // leaq (%rdi,%rsi), %rcx - WORD $0x0148; BYTE $0xd9 // addq %rbx, %rcx - LONG $0xd04d8948 // movq %rcx, $-48(%rbp) + LONG $0x000a850f; WORD $0x0000 // jne LBB35_33, $10(%rip) + WORD $0x014c; BYTE $0xc9 // addq %r9, %rcx WORD $0x8948; BYTE $0x0a // movq %rcx, (%rdx) + LONG $0xd04d8948 // movq %rcx, $-48(%rbp) -LBB40_33: - WORD $0x0148; BYTE $0xde // addq %rbx, %rsi +LBB35_33: LONG $0x02c68348 // addq $2, %rsi - WORD $0x894c; BYTE $0xf9 // movq %r15, %rcx - WORD $0x2948; BYTE $0xd9 // subq %rbx, %rcx - LONG $0xfec18348 // addq $-2, %rcx LONG $0xfec78349 // addq $-2, %r15 - WORD $0x3949; BYTE $0xdf // cmpq %rbx, %r15 - WORD $0x8949; BYTE $0xcf // movq %rcx, %r15 - LONG $0xff90850f; WORD $0xffff // jne LBB40_26, $-112(%rip) - LONG $0xfffe5be9; BYTE $0xff // jmp LBB40_11, $-421(%rip) - -LBB40_34: - WORD $0x0148; BYTE $0xde // addq %rbx, %rsi - WORD $0xff48; BYTE $0xc6 // incq %rsi - -LBB40_35: - WORD $0x294c; BYTE $0xce // subq %r9, %rsi - WORD $0x8948; BYTE $0xf0 // movq %rsi, %rax - LONG $0xfffe4ae9; BYTE $0xff // jmp LBB40_11, $-438(%rip) + WORD $0x894c; BYTE $0xff // movq %r15, %rdi + WORD $0x8548; BYTE $0xff // testq %rdi, %rdi + LONG $0xff9d850f; WORD $0xffff // jne LBB35_27, $-99(%rip) + LONG $0xfffe86e9; BYTE $0xff // jmp LBB35_12, $-378(%rip) -LBB40_36: - LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax - WORD $0xf980; BYTE $0x22 // cmpb $34, %cl - LONG $0xfe3a850f; WORD $0xffff // jne LBB40_11, $-454(%rip) - WORD $0x0148; BYTE $0xde // addq %rbx, %rsi - LONG $0xffffdde9; BYTE $0xff // jmp LBB40_35, $-35(%rip) +LBB35_34: + WORD $0x294c; BYTE $0xd9 // subq %r11, %rcx + WORD $0x8948; BYTE $0xc8 // movq %rcx, %rax + LONG $0xfffe7be9; BYTE $0xff // jmp LBB35_12, $-389(%rip) -LBB40_38: +LBB35_35: WORD $0x854d; BYTE $0xff // testq %r15, %r15 - LONG $0x002f840f; WORD $0x0000 // je LBB40_17, $47(%rip) + LONG $0x0036840f; WORD $0x0000 // je LBB35_13, $54(%rip) LONG $0xd07d8348; BYTE $0xff // cmpq $-1, $-48(%rbp) - LONG $0x0010850f; WORD $0x0000 // jne LBB40_41, $16(%rip) - WORD $0x894c; BYTE $0xc8 // movq %r9, %rax + LONG $0x0010850f; WORD $0x0000 // jne LBB35_38, $16(%rip) + WORD $0x894c; BYTE $0xd8 // movq %r11, %rax WORD $0xf748; BYTE $0xd0 // notq %rax WORD $0x0148; BYTE $0xf0 // addq %rsi, %rax LONG $0xd0458948 // movq %rax, $-48(%rbp) WORD $0x8948; BYTE $0x02 // movq %rax, (%rdx) -LBB40_41: - WORD $0xff48; BYTE $0xc6 // incq %rsi - WORD $0xff49; BYTE $0xcf // decq %r15 - WORD $0x854d; BYTE $0xff // testq %r15, %r15 - LONG $0xff22850f; WORD $0xffff // jne LBB40_25, $-222(%rip) - LONG $0xffffa5e9; BYTE $0xff // jmp LBB40_35, $-91(%rip) - -LBB40_17: +LBB35_38: + WORD $0xff48; BYTE $0xc6 // incq %rsi + WORD $0xff49; BYTE $0xcf // decq %r15 LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax - LONG $0xfffdeee9; BYTE $0xff // jmp LBB40_11, $-530(%rip) - QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90 - -_unescape: - BYTE $0x55 // pushq %rbp - WORD $0x8948; BYTE $0xe5 // movq %rsp, %rbp - WORD $0x5741 // pushq %r15 - WORD $0x5641 // pushq %r14 - WORD $0x5541 // pushq %r13 - WORD $0x5441 // pushq %r12 - BYTE $0x53 // pushq %rbx - LONG $0x18ec8348 // subq $24, %rsp - WORD $0x8b4c; BYTE $0x2f // movq (%rdi), %r13 - WORD $0x294c; BYTE $0xee // subq %r13, %rsi - LONG $0xffc3c748; WORD $0xffff; BYTE $0xff // movq $-1, %rbx - WORD $0x8548; BYTE $0xf6 // testq %rsi, %rsi - LONG $0x00d38e0f; WORD $0x0000 // jle LBB41_13, $211(%rip) - WORD $0x8949; BYTE $0xd6 // movq %rdx, %r14 - WORD $0x8949; BYTE $0xff // movq %rdi, %r15 - LONG $0x01458d49 // leaq $1(%r13), %rax - LONG $0x4db60f41; BYTE $0x01 // movzbl $1(%r13), %ecx - LONG $0x43158d48; WORD $0x0077; BYTE $0x00 // leaq $30531(%rip), %rdx /* __UnquoteTab(%rip) */ - LONG $0x110cb60f // movzbl (%rcx,%rdx), %ecx - LONG $0x00fff981; WORD $0x0000 // cmpl $255, %ecx - LONG $0x0017840f; WORD $0x0000 // je LBB41_4, $23(%rip) - WORD $0xc985 // testl %ecx, %ecx - LONG $0x0021850f; WORD $0x0000 // jne LBB41_6, $33(%rip) - WORD $0x8949; BYTE $0x07 // movq %rax, (%r15) - LONG $0xfdc3c748; WORD $0xffff; BYTE $0xff // movq $-3, %rbx - LONG $0x000096e9; BYTE $0x00 // jmp LBB41_13, $150(%rip) - -LBB41_4: - LONG $0x03fe8348 // cmpq $3, %rsi - LONG $0x0019870f; WORD $0x0000 // ja LBB41_7, $25(%rip) - WORD $0x8949; BYTE $0x07 // movq %rax, (%r15) - LONG $0x000084e9; BYTE $0x00 // jmp LBB41_13, $132(%rip) - -LBB41_6: - WORD $0x8841; BYTE $0x0e // movb %cl, (%r14) - LONG $0x02078349 // addq $2, (%r15) - LONG $0x000001bb; BYTE $0x00 // movl $1, %ebx - LONG $0x000073e9; BYTE $0x00 // jmp LBB41_13, $115(%rip) - -LBB41_7: - LONG $0x024d8b41 // movl $2(%r13), %ecx - WORD $0xc889 // movl %ecx, %eax - WORD $0xd0f7 // notl %eax - LONG $0xcfd0918d; WORD $0xcfcf // leal $-808464432(%rcx), %edx - LONG $0x80808025; BYTE $0x80 // andl $-2139062144, %eax - WORD $0xd085 // testl %edx, %eax - LONG $0x004a850f; WORD $0x0000 // jne LBB41_11, $74(%rip) - LONG $0x1919918d; WORD $0x1919 // leal $421075225(%rcx), %edx - WORD $0xca09 // orl %ecx, %edx - LONG $0x8080c2f7; WORD $0x8080 // testl $-2139062144, %edx - LONG $0x0036850f; WORD $0x0000 // jne LBB41_11, $54(%rip) - WORD $0xca89 // movl %ecx, %edx - LONG $0x7f7fe281; WORD $0x7f7f // andl $2139062143, %edx - LONG $0xc0c0c0bf; BYTE $0xc0 // movl $-1061109568, %edi - WORD $0xd729 // subl %edx, %edi - LONG $0x46469a8d; WORD $0x4646 // leal $1179010630(%rdx), %ebx - WORD $0xc721 // andl %eax, %edi - WORD $0xdf85 // testl %ebx, %edi - LONG $0x0017850f; WORD $0x0000 // jne LBB41_11, $23(%rip) - LONG $0xe0e0e0bf; BYTE $0xe0 // movl $-522133280, %edi - WORD $0xd729 // subl %edx, %edi - LONG $0x3939c281; WORD $0x3939 // addl $960051513, %edx - WORD $0xf821 // andl %edi, %eax - WORD $0xd085 // testl %edx, %eax - LONG $0x0020840f; WORD $0x0000 // je LBB41_14, $32(%rip) - -LBB41_11: - LONG $0x02c58349 // addq $2, %r13 - WORD $0x894d; BYTE $0x2f // movq %r13, (%r15) - -LBB41_12: - LONG $0xfec3c748; WORD $0xffff; BYTE $0xff // movq $-2, %rbx - -LBB41_13: - WORD $0x8948; BYTE $0xd8 // movq %rbx, %rax - LONG $0x18c48348 // addq $24, %rsp - BYTE $0x5b // popq %rbx - WORD $0x5c41 // popq %r12 - WORD $0x5d41 // popq %r13 - WORD $0x5e41 // popq %r14 - WORD $0x5f41 // popq %r15 - BYTE $0x5d // popq %rbp - BYTE $0xc3 // retq - -LBB41_14: - WORD $0xc90f // bswapl %ecx - WORD $0xc889 // movl %ecx, %eax - WORD $0xd0f7 // notl %eax - WORD $0xe8c1; BYTE $0x04 // shrl $4, %eax - LONG $0x01010125; BYTE $0x01 // andl $16843009, %eax - WORD $0x048d; BYTE $0xc0 // leal (%rax,%rax,8), %eax - LONG $0x0f0fe181; WORD $0x0f0f // andl $252645135, %ecx - WORD $0xc101 // addl %eax, %ecx - WORD $0xc889 // movl %ecx, %eax - WORD $0xe8c1; BYTE $0x04 // shrl $4, %eax - WORD $0xc809 // orl %ecx, %eax - WORD $0xc189 // movl %eax, %ecx - WORD $0xe9c1; BYTE $0x08 // shrl $8, %ecx - LONG $0xff00e181; WORD $0x0000 // andl $65280, %ecx - LONG $0xe0b60f44 // movzbl %al, %r12d - WORD $0x0941; BYTE $0xcc // orl %ecx, %r12d - LONG $0x06558d49 // leaq $6(%r13), %rdx - WORD $0x8949; BYTE $0x17 // movq %rdx, (%r15) - LONG $0x7ffc8341 // cmpl $127, %r12d - LONG $0x004c860f; WORD $0x0000 // jbe LBB41_18, $76(%rip) - LONG $0xfffc8141; WORD $0x0007; BYTE $0x00 // cmpl $2047, %r12d - LONG $0x004c860f; WORD $0x0000 // jbe LBB41_19, $76(%rip) - QUAD $0xffff200024bc8d41 // leal $-57344(%r12), %edi - LONG $0xf7ffff81; WORD $0xffff // cmpl $-2049, %edi - LONG $0x0055870f; WORD $0x0000 // ja LBB41_20, $85(%rip) - WORD $0xe9c1; BYTE $0x0c // shrl $12, %ecx - WORD $0xc980; BYTE $0xe0 // orb $-32, %cl - WORD $0x8841; BYTE $0x0e // movb %cl, (%r14) - LONG $0x06ecc141 // shrl $6, %r12d - LONG $0x3fe48041 // andb $63, %r12b - LONG $0x80cc8041 // orb $-128, %r12b - LONG $0x01668845 // movb %r12b, $1(%r14) - WORD $0x3f24 // andb $63, %al - WORD $0x800c // orb $-128, %al - LONG $0x02468841 // movb %al, $2(%r14) - LONG $0x000003bb; BYTE $0x00 // movl $3, %ebx - LONG $0xffff5fe9; BYTE $0xff // jmp LBB41_13, $-161(%rip) - -LBB41_18: - WORD $0x8841; BYTE $0x06 // movb %al, (%r14) - LONG $0x000001bb; BYTE $0x00 // movl $1, %ebx - LONG $0xffff52e9; BYTE $0xff // jmp LBB41_13, $-174(%rip) - -LBB41_19: - LONG $0x06ecc141 // shrl $6, %r12d - LONG $0xc0cc8041 // orb $-64, %r12b - WORD $0x8845; BYTE $0x26 // movb %r12b, (%r14) - WORD $0x3f24 // andb $63, %al - WORD $0x800c // orb $-128, %al - LONG $0x01468841 // movb %al, $1(%r14) - LONG $0x000002bb; BYTE $0x00 // movl $2, %ebx - LONG $0xffff35e9; BYTE $0xff // jmp LBB41_13, $-203(%rip) - -LBB41_20: - LONG $0xfcc3c748; WORD $0xffff; BYTE $0xff // movq $-4, %rbx - LONG $0x06fe8348 // cmpq $6, %rsi - LONG $0xff24820f; WORD $0xffff // jb LBB41_13, $-220(%rip) - LONG $0xfffc8141; WORD $0x00db; BYTE $0x00 // cmpl $56319, %r12d - LONG $0xff17870f; WORD $0xffff // ja LBB41_13, $-233(%rip) - WORD $0x3a80; BYTE $0x5c // cmpb $92, (%rdx) - LONG $0xff0e850f; WORD $0xffff // jne LBB41_13, $-242(%rip) - LONG $0x077d8041; BYTE $0x75 // cmpb $117, $7(%r13) - LONG $0xff03850f; WORD $0xffff // jne LBB41_13, $-253(%rip) - LONG $0x08458d49 // leaq $8(%r13), %rax - LONG $0xc8458948 // movq %rax, $-56(%rbp) - LONG $0x087d8b41 // movl $8(%r13), %edi - WORD $0x7d89; BYTE $0xd4 // movl %edi, $-44(%rbp) - LONG $0xff9c65e8; BYTE $0xff // callq _unhex16_is, $-25499(%rip) - WORD $0xc084 // testb %al, %al - LONG $0x0050840f; WORD $0x0000 // je LBB41_27, $80(%rip) - WORD $0x558b; BYTE $0xd4 // movl $-44(%rbp), %edx - WORD $0xca0f // bswapl %edx - WORD $0xd089 // movl %edx, %eax - WORD $0xd0f7 // notl %eax - WORD $0xe8c1; BYTE $0x04 // shrl $4, %eax - LONG $0x01010125; BYTE $0x01 // andl $16843009, %eax - WORD $0x048d; BYTE $0xc0 // leal (%rax,%rax,8), %eax - LONG $0x0f0fe281; WORD $0x0f0f // andl $252645135, %edx - WORD $0xc201 // addl %eax, %edx - WORD $0xd189 // movl %edx, %ecx - WORD $0xe9c1; BYTE $0x04 // shrl $4, %ecx - WORD $0xd109 // orl %edx, %ecx - WORD $0xb60f; BYTE $0xc1 // movzbl %cl, %eax - WORD $0xe9c1; BYTE $0x08 // shrl $8, %ecx - LONG $0xff00e181; WORD $0x0000 // andl $65280, %ecx - WORD $0x148d; BYTE $0x01 // leal (%rcx,%rax), %edx - LONG $0x2000c281; WORD $0xffff // addl $-57344, %edx - LONG $0xfbfffa81; WORD $0xffff // cmpl $-1025, %edx - LONG $0x0018870f; WORD $0x0000 // ja LBB41_28, $24(%rip) - LONG $0xc8458b48 // movq $-56(%rbp), %rax - WORD $0x8949; BYTE $0x07 // movq %rax, (%r15) - LONG $0xfffe97e9; BYTE $0xff // jmp LBB41_13, $-361(%rip) - -LBB41_27: - LONG $0xc8458b48 // movq $-56(%rbp), %rax - WORD $0x8949; BYTE $0x07 // movq %rax, (%r15) - LONG $0xfffe84e9; BYTE $0xff // jmp LBB41_12, $-380(%rip) + WORD $0x854d; BYTE $0xff // testq %r15, %r15 + LONG $0xff4d850f; WORD $0xffff // jne LBB35_26, $-179(%rip) + LONG $0xfffe3ce9; BYTE $0xff // jmp LBB35_12, $-452(%rip) -LBB41_28: - WORD $0xc109 // orl %eax, %ecx - LONG $0x0ae4c141 // shll $10, %r12d - WORD $0xc889 // movl %ecx, %eax - WORD $0x0144; BYTE $0xe0 // addl %r12d, %eax - WORD $0x0144; BYTE $0xe1 // addl %r12d, %ecx - LONG $0x2400c181; WORD $0xfca0 // addl $-56613888, %ecx - WORD $0xca89 // movl %ecx, %edx - WORD $0xeac1; BYTE $0x12 // shrl $18, %edx - WORD $0xca80; BYTE $0xf0 // orb $-16, %dl - WORD $0x8841; BYTE $0x16 // movb %dl, (%r14) - WORD $0xca89 // movl %ecx, %edx - WORD $0xeac1; BYTE $0x0c // shrl $12, %edx - WORD $0xe280; BYTE $0x3f // andb $63, %dl - WORD $0xca80; BYTE $0x80 // orb $-128, %dl - LONG $0x01568841 // movb %dl, $1(%r14) - WORD $0xe9c1; BYTE $0x06 // shrl $6, %ecx - WORD $0xe180; BYTE $0x3f // andb $63, %cl - WORD $0xc980; BYTE $0x80 // orb $-128, %cl - LONG $0x024e8841 // movb %cl, $2(%r14) - WORD $0x3f24 // andb $63, %al - WORD $0x800c // orb $-128, %al - LONG $0x03468841 // movb %al, $3(%r14) - LONG $0x0cc58349 // addq $12, %r13 - WORD $0x894d; BYTE $0x2f // movq %r13, (%r15) - LONG $0x000004bb; BYTE $0x00 // movl $4, %ebx - LONG $0xfffe37e9; BYTE $0xff // jmp LBB41_13, $-457(%rip) - QUAD $0x0000000000000000; LONG $0x00000000; BYTE $0x00 // .p2align 4, 0x00 +LBB35_13: + LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq $-1, %rax + LONG $0xfffe30e9; BYTE $0xff // jmp LBB35_12, $-464(%rip) + QUAD $0x0000000000000000; WORD $0x0000 // .p2align 4, 0x00 _POW10_M128_TAB: QUAD $0x1732c869cd60e453 // .quad 1671618768450675795 @@ -11882,7 +12282,7 @@ _Digits: QUAD $0x3939383937393639 // .ascii 8, '96979899' QUAD $0x0000000000000000 // .p2align 4, 0x00 -_LB_a0a1aa40: // _pow10_ceil_sig.g +_LB_9e78d5f3: // _pow10_ceil_sig.g QUAD $0xff77b1fcbebcdc4f // .quad -38366372719436721 QUAD $0x25e8e89c13bb0f7b // .quad 2731688931043774331 QUAD $0x9faacf3df73609b1 // .quad -6941508010590729807 @@ -14537,7 +14937,7 @@ _P10_TAB: QUAD $0x4480f0cf064dd592 // .quad 0x4480f0cf064dd592 QUAD $0x0000000000000000 // .p2align 4, 0x00 -_LB_96b09a0f: // _pow10_ceil_sig_f32.g +_LB_effe8bde: // _pow10_ceil_sig_f32.g QUAD $0x81ceb32c4b43fcf5 // .quad -9093133594791772939 QUAD $0xa2425ff75e14fc32 // .quad -6754730975062328270 QUAD $0xcad2f7f5359a3b3f // .quad -3831727700400522433 @@ -14621,14 +15021,14 @@ TEXT ·__f32toa(SB), NOSPLIT | NOFRAME, $0 - 24 _entry: MOVQ (TLS), R14 - LEAQ -56(SP), R12 + LEAQ -48(SP), R12 CMPQ R12, 16(R14) JBE _stack_grow _f32toa: MOVQ out+0(FP), DI MOVSD val+8(FP), X0 - CALL ·__native_entry__+28688(SB) // _f32toa + CALL ·__native_entry__+31760(SB) // _f32toa MOVQ AX, ret+16(FP) RET @@ -14648,7 +15048,7 @@ _entry: _f64toa: MOVQ out+0(FP), DI MOVSD val+8(FP), X0 - CALL ·__native_entry__+464(SB) // _f64toa + CALL ·__native_entry__+160(SB) // _f64toa MOVQ AX, ret+16(FP) RET @@ -14656,12 +15056,12 @@ _stack_grow: CALL runtime·morestack_noctxt<>(SB) JMP _entry -TEXT ·__get_by_path(SB), NOSPLIT | NOFRAME, $0 - 32 +TEXT ·__get_by_path(SB), NOSPLIT | NOFRAME, $0 - 40 NO_LOCAL_POINTERS _entry: MOVQ (TLS), R14 - LEAQ -264(SP), R12 + LEAQ -240(SP), R12 CMPQ R12, 16(R14) JBE _stack_grow @@ -14669,8 +15069,9 @@ _get_by_path: MOVQ s+0(FP), DI MOVQ p+8(FP), SI MOVQ path+16(FP), DX - CALL ·__native_entry__+26432(SB) // _get_by_path - MOVQ AX, ret+24(FP) + MOVQ m+24(FP), CX + CALL ·__native_entry__+26384(SB) // _get_by_path + MOVQ AX, ret+32(FP) RET _stack_grow: @@ -14691,7 +15092,7 @@ _html_escape: MOVQ nb+8(FP), SI MOVQ dp+16(FP), DX MOVQ dn+24(FP), CX - CALL ·__native_entry__+9584(SB) // _html_escape + CALL ·__native_entry__+9072(SB) // _html_escape MOVQ AX, ret+32(FP) RET @@ -14711,7 +15112,7 @@ _entry: _i64toa: MOVQ out+0(FP), DI MOVQ val+8(FP), SI - CALL ·__native_entry__+3744(SB) // _i64toa + CALL ·__native_entry__+3424(SB) // _i64toa MOVQ AX, ret+16(FP) RET @@ -14732,7 +15133,7 @@ _lspace: MOVQ sp+0(FP), DI MOVQ nb+8(FP), SI MOVQ off+16(FP), DX - CALL ·__native_entry__+80(SB) // _lspace + CALL ·__native_entry__+16(SB) // _lspace MOVQ AX, ret+24(FP) RET @@ -14745,7 +15146,7 @@ TEXT ·__quote(SB), NOSPLIT | NOFRAME, $0 - 48 _entry: MOVQ (TLS), R14 - LEAQ -80(SP), R12 + LEAQ -64(SP), R12 CMPQ R12, 16(R14) JBE _stack_grow @@ -14755,7 +15156,7 @@ _quote: MOVQ dp+16(FP), DX MOVQ dn+24(FP), CX MOVQ flags+32(FP), R8 - CALL ·__native_entry__+5472(SB) // _quote + CALL ·__native_entry__+4864(SB) // _quote MOVQ AX, ret+40(FP) RET @@ -14777,7 +15178,7 @@ _skip_array: MOVQ p+8(FP), SI MOVQ m+16(FP), DX MOVQ flags+24(FP), CX - CALL ·__native_entry__+19184(SB) // _skip_array + CALL ·__native_entry__+18112(SB) // _skip_array MOVQ AX, ret+32(FP) RET @@ -14797,7 +15198,7 @@ _entry: _skip_number: MOVQ s+0(FP), DI MOVQ p+8(FP), SI - CALL ·__native_entry__+22528(SB) // _skip_number + CALL ·__native_entry__+22128(SB) // _skip_number MOVQ AX, ret+16(FP) RET @@ -14819,7 +15220,7 @@ _skip_object: MOVQ p+8(FP), SI MOVQ m+16(FP), DX MOVQ flags+24(FP), CX - CALL ·__native_entry__+21088(SB) // _skip_object + CALL ·__native_entry__+20512(SB) // _skip_object MOVQ AX, ret+32(FP) RET @@ -14841,7 +15242,7 @@ _skip_one: MOVQ p+8(FP), SI MOVQ m+16(FP), DX MOVQ flags+24(FP), CX - CALL ·__native_entry__+22688(SB) // _skip_one + CALL ·__native_entry__+22288(SB) // _skip_one MOVQ AX, ret+32(FP) RET @@ -14854,14 +15255,14 @@ TEXT ·__skip_one_fast(SB), NOSPLIT | NOFRAME, $0 - 24 _entry: MOVQ (TLS), R14 - LEAQ -160(SP), R12 + LEAQ -136(SP), R12 CMPQ R12, 16(R14) JBE _stack_grow _skip_one_fast: MOVQ s+0(FP), DI MOVQ p+8(FP), SI - CALL ·__native_entry__+22912(SB) // _skip_one_fast + CALL ·__native_entry__+22512(SB) // _skip_one_fast MOVQ AX, ret+16(FP) RET @@ -14881,7 +15282,7 @@ _entry: _u64toa: MOVQ out+0(FP), DI MOVQ val+8(FP), SI - CALL ·__native_entry__+4016(SB) // _u64toa + CALL ·__native_entry__+3552(SB) // _u64toa MOVQ AX, ret+16(FP) RET @@ -14894,7 +15295,7 @@ TEXT ·__unquote(SB), NOSPLIT | NOFRAME, $0 - 48 _entry: MOVQ (TLS), R14 - LEAQ -128(SP), R12 + LEAQ -88(SP), R12 CMPQ R12, 16(R14) JBE _stack_grow @@ -14904,7 +15305,7 @@ _unquote: MOVQ dp+16(FP), DX MOVQ ep+24(FP), CX MOVQ flags+32(FP), R8 - CALL ·__native_entry__+7184(SB) // _unquote + CALL ·__native_entry__+6704(SB) // _unquote MOVQ AX, ret+40(FP) RET @@ -14925,7 +15326,7 @@ _validate_one: MOVQ s+0(FP), DI MOVQ p+8(FP), SI MOVQ m+16(FP), DX - CALL ·__native_entry__+22736(SB) // _validate_one + CALL ·__native_entry__+22336(SB) // _validate_one MOVQ AX, ret+24(FP) RET @@ -14946,7 +15347,7 @@ _validate_utf8: MOVQ s+0(FP), DI MOVQ p+8(FP), SI MOVQ m+16(FP), DX - CALL ·__native_entry__+27456(SB) // _validate_utf8 + CALL ·__native_entry__+30528(SB) // _validate_utf8 MOVQ AX, ret+24(FP) RET @@ -14965,7 +15366,7 @@ _entry: _validate_utf8_fast: MOVQ s+0(FP), DI - CALL ·__native_entry__+28128(SB) // _validate_utf8_fast + CALL ·__native_entry__+31200(SB) // _validate_utf8_fast MOVQ AX, ret+8(FP) RET @@ -14978,7 +15379,7 @@ TEXT ·__value(SB), NOSPLIT | NOFRAME, $0 - 48 _entry: MOVQ (TLS), R14 - LEAQ -368(SP), R12 + LEAQ -328(SP), R12 CMPQ R12, 16(R14) JBE _stack_grow @@ -14988,7 +15389,7 @@ _value: MOVQ p+16(FP), DX MOVQ v+24(FP), CX MOVQ flags+32(FP), R8 - CALL ·__native_entry__+13216(SB) // _value + CALL ·__native_entry__+12272(SB) // _value MOVQ AX, ret+40(FP) RET @@ -15001,7 +15402,7 @@ TEXT ·__vnumber(SB), NOSPLIT | NOFRAME, $0 - 24 _entry: MOVQ (TLS), R14 - LEAQ -280(SP), R12 + LEAQ -240(SP), R12 CMPQ R12, 16(R14) JBE _stack_grow @@ -15009,7 +15410,7 @@ _vnumber: MOVQ s+0(FP), DI MOVQ p+8(FP), SI MOVQ v+16(FP), DX - LEAQ ·__native_entry__+16928(SB), AX // _vnumber + LEAQ ·__native_entry__+15728(SB), AX // _vnumber JMP AX _stack_grow: @@ -15029,7 +15430,7 @@ _vsigned: MOVQ s+0(FP), DI MOVQ p+8(FP), SI MOVQ v+16(FP), DX - LEAQ ·__native_entry__+18464(SB), AX // _vsigned + LEAQ ·__native_entry__+17376(SB), AX // _vsigned JMP AX _stack_grow: @@ -15041,7 +15442,7 @@ TEXT ·__vstring(SB), NOSPLIT | NOFRAME, $0 - 32 _entry: MOVQ (TLS), R14 - LEAQ -128(SP), R12 + LEAQ -136(SP), R12 CMPQ R12, 16(R14) JBE _stack_grow @@ -15050,7 +15451,7 @@ _vstring: MOVQ p+8(FP), SI MOVQ v+16(FP), DX MOVQ flags+24(FP), CX - LEAQ ·__native_entry__+15408(SB), AX // _vstring + LEAQ ·__native_entry__+14112(SB), AX // _vstring JMP AX _stack_grow: @@ -15062,7 +15463,7 @@ TEXT ·__vunsigned(SB), NOSPLIT | NOFRAME, $0 - 24 _entry: MOVQ (TLS), R14 - LEAQ -24(SP), R12 + LEAQ -16(SP), R12 CMPQ R12, 16(R14) JBE _stack_grow @@ -15070,7 +15471,7 @@ _vunsigned: MOVQ s+0(FP), DI MOVQ p+8(FP), SI MOVQ v+16(FP), DX - LEAQ ·__native_entry__+18816(SB), AX // _vunsigned + LEAQ ·__native_entry__+17760(SB), AX // _vunsigned JMP AX _stack_grow: diff --git a/vendor/github.com/bytedance/sonic/internal/native/sse/native_subr_amd64.go b/vendor/github.com/bytedance/sonic/internal/native/sse/native_subr_amd64.go index 26dee6de2..2682825ed 100644 --- a/vendor/github.com/bytedance/sonic/internal/native/sse/native_subr_amd64.go +++ b/vendor/github.com/bytedance/sonic/internal/native/sse/native_subr_amd64.go @@ -9,53 +9,53 @@ package sse func __native_entry__() uintptr var ( - _subr__f32toa = __native_entry__() + 28688 - _subr__f64toa = __native_entry__() + 464 - _subr__get_by_path = __native_entry__() + 26432 - _subr__html_escape = __native_entry__() + 9584 - _subr__i64toa = __native_entry__() + 3744 - _subr__lspace = __native_entry__() + 80 - _subr__quote = __native_entry__() + 5472 - _subr__skip_array = __native_entry__() + 19184 - _subr__skip_number = __native_entry__() + 22528 - _subr__skip_object = __native_entry__() + 21088 - _subr__skip_one = __native_entry__() + 22688 - _subr__skip_one_fast = __native_entry__() + 22912 - _subr__u64toa = __native_entry__() + 4016 - _subr__unquote = __native_entry__() + 7184 - _subr__validate_one = __native_entry__() + 22736 - _subr__validate_utf8 = __native_entry__() + 27456 - _subr__validate_utf8_fast = __native_entry__() + 28128 - _subr__value = __native_entry__() + 13216 - _subr__vnumber = __native_entry__() + 16928 - _subr__vsigned = __native_entry__() + 18464 - _subr__vstring = __native_entry__() + 15408 - _subr__vunsigned = __native_entry__() + 18816 + _subr__f32toa = __native_entry__() + 31760 + _subr__f64toa = __native_entry__() + 160 + _subr__get_by_path = __native_entry__() + 26384 + _subr__html_escape = __native_entry__() + 9072 + _subr__i64toa = __native_entry__() + 3424 + _subr__lspace = __native_entry__() + 16 + _subr__quote = __native_entry__() + 4864 + _subr__skip_array = __native_entry__() + 18112 + _subr__skip_number = __native_entry__() + 22128 + _subr__skip_object = __native_entry__() + 20512 + _subr__skip_one = __native_entry__() + 22288 + _subr__skip_one_fast = __native_entry__() + 22512 + _subr__u64toa = __native_entry__() + 3552 + _subr__unquote = __native_entry__() + 6704 + _subr__validate_one = __native_entry__() + 22336 + _subr__validate_utf8 = __native_entry__() + 30528 + _subr__validate_utf8_fast = __native_entry__() + 31200 + _subr__value = __native_entry__() + 12272 + _subr__vnumber = __native_entry__() + 15728 + _subr__vsigned = __native_entry__() + 17376 + _subr__vstring = __native_entry__() + 14112 + _subr__vunsigned = __native_entry__() + 17760 ) const ( - _stack__f32toa = 56 + _stack__f32toa = 48 _stack__f64toa = 80 - _stack__get_by_path = 264 + _stack__get_by_path = 240 _stack__html_escape = 64 _stack__i64toa = 16 _stack__lspace = 8 - _stack__quote = 80 + _stack__quote = 64 _stack__skip_array = 128 _stack__skip_number = 72 _stack__skip_object = 128 _stack__skip_one = 128 - _stack__skip_one_fast = 160 + _stack__skip_one_fast = 136 _stack__u64toa = 8 - _stack__unquote = 128 + _stack__unquote = 88 _stack__validate_one = 128 _stack__validate_utf8 = 48 _stack__validate_utf8_fast = 24 - _stack__value = 368 - _stack__vnumber = 280 + _stack__value = 328 + _stack__vnumber = 240 _stack__vsigned = 16 - _stack__vstring = 128 - _stack__vunsigned = 24 + _stack__vstring = 136 + _stack__vunsigned = 16 ) var ( diff --git a/vendor/github.com/bytedance/sonic/internal/native/types/types.go b/vendor/github.com/bytedance/sonic/internal/native/types/types.go index 00437303c..e4e75705c 100644 --- a/vendor/github.com/bytedance/sonic/internal/native/types/types.go +++ b/vendor/github.com/bytedance/sonic/internal/native/types/types.go @@ -76,6 +76,10 @@ const ( ERR_FLOAT_INFINITY ParsingError = 8 ERR_MISMATCH ParsingError = 9 ERR_INVALID_UTF8 ParsingError = 10 + + // error code used in ast + ERR_NOT_FOUND ParsingError = 33 + ERR_UNSUPPORT_TYPE ParsingError = 34 ) var _ParsingErrors = []string{ diff --git a/vendor/github.com/bytedance/sonic/internal/resolver/resolver.go b/vendor/github.com/bytedance/sonic/internal/resolver/resolver.go index 796d5d823..795434f4e 100644 --- a/vendor/github.com/bytedance/sonic/internal/resolver/resolver.go +++ b/vendor/github.com/bytedance/sonic/internal/resolver/resolver.go @@ -152,8 +152,8 @@ func resolveFields(vt reflect.Type) []FieldMeta { } /* get the index to the last offset */ - fvt := fv.typ idx := len(path) - 1 + fvt := path[idx].Type /* do not dereference into fields */ if path[idx].Kind == F_deref { diff --git a/vendor/github.com/bytedance/sonic/internal/rt/fastmem.go b/vendor/github.com/bytedance/sonic/internal/rt/fastmem.go index 358ce80ce..5bf80dd4e 100644 --- a/vendor/github.com/bytedance/sonic/internal/rt/fastmem.go +++ b/vendor/github.com/bytedance/sonic/internal/rt/fastmem.go @@ -87,7 +87,6 @@ func GuardSlice(buf *[]byte, n int) { copy(tmp, *buf) *buf = tmp } - return } //go:nosplit diff --git a/vendor/github.com/bytedance/sonic/internal/rt/fastvalue.go b/vendor/github.com/bytedance/sonic/internal/rt/fastvalue.go index 87df6b94a..2b2757f5b 100644 --- a/vendor/github.com/bytedance/sonic/internal/rt/fastvalue.go +++ b/vendor/github.com/bytedance/sonic/internal/rt/fastvalue.go @@ -22,14 +22,23 @@ import ( ) var ( - reflectRtypeItab = findReflectRtypeItab() + reflectRtypeItab = findReflectRtypeItab() ) +// GoType.KindFlags const const ( F_direct = 1 << 5 F_kind_mask = (1 << 5) - 1 ) +// GoType.Flags const +const ( + tflagUncommon uint8 = 1 << 0 + tflagExtraStar uint8 = 1 << 1 + tflagNamed uint8 = 1 << 2 + tflagRegularMemory uint8 = 1 << 3 +) + type GoType struct { Size uintptr PtrData uintptr @@ -44,6 +53,10 @@ type GoType struct { PtrToSelf int32 } +func (self *GoType) IsNamed() bool { + return (self.Flags & tflagNamed) != 0 +} + func (self *GoType) Kind() reflect.Kind { return reflect.Kind(self.KindFlags & F_kind_mask) } diff --git a/vendor/github.com/bytedance/sonic/internal/rt/stackmap.go b/vendor/github.com/bytedance/sonic/internal/rt/stackmap.go index e2c28c598..84ed9a95f 100644 --- a/vendor/github.com/bytedance/sonic/internal/rt/stackmap.go +++ b/vendor/github.com/bytedance/sonic/internal/rt/stackmap.go @@ -152,6 +152,7 @@ type StackMapBuilder struct { b Bitmap } +//go:nocheckptr func (self *StackMapBuilder) Build() (p *StackMap) { nb := len(self.b.B) bm := mallocgc(_StackMapSize + uintptr(nb) - 1, byteType, false) diff --git a/vendor/github.com/bytedance/sonic/introduction-1.png b/vendor/github.com/bytedance/sonic/introduction-1.png Binary files differdeleted file mode 100644 index 3a2845ec6..000000000 --- a/vendor/github.com/bytedance/sonic/introduction-1.png +++ /dev/null diff --git a/vendor/github.com/bytedance/sonic/introduction-2.png b/vendor/github.com/bytedance/sonic/introduction-2.png Binary files differdeleted file mode 100644 index 25b16638c..000000000 --- a/vendor/github.com/bytedance/sonic/introduction-2.png +++ /dev/null diff --git a/vendor/github.com/bytedance/sonic/loader/funcdata_go115.go b/vendor/github.com/bytedance/sonic/loader/funcdata_go115.go index f35f03d56..a2e3e65f9 100644 --- a/vendor/github.com/bytedance/sonic/loader/funcdata_go115.go +++ b/vendor/github.com/bytedance/sonic/loader/funcdata_go115.go @@ -1,5 +1,5 @@ -// go:build go1.15 && !go1.18 -// +build go1.15,!go1.18 +//go:build go1.15 && !go1.16 +// +build go1.15,!go1.16 /* * Copyright 2021 ByteDance Inc. @@ -28,7 +28,7 @@ import ( ) const ( - _Magic uint32 = 0xfffffff0 + _Magic uint32 = 0xfffffffa ) type pcHeader struct { @@ -38,7 +38,6 @@ type pcHeader struct { ptrSize uint8 // size of a ptr in bytes nfunc int // number of functions in the module nfiles uint // number of entries in the file tab - textStart uintptr // base for function entry PC offsets in this module, equal to moduledata.text funcnameOffset uintptr // offset to the funcnametab variable from pcHeader cuOffset uintptr // offset to the cutab variable from pcHeader filetabOffset uintptr // offset to the filetab variable from pcHeader @@ -64,9 +63,7 @@ type moduledata struct { noptrbss, enoptrbss uintptr end, gcdata, gcbss uintptr types, etypes uintptr - rodata uintptr - gofunc uintptr // go.func.* is actual funcinfo object in image - + textsectmap []textSection // see runtime/symtab.go: textAddr() typelinks []int32 // offsets from types itablinks []*rt.GoItab @@ -91,7 +88,7 @@ type moduledata struct { } type _func struct { - entryOff uint32 // start pc, as offset from moduledata.text/pcHeader.textStart + entry uintptr // start pc, as offset from moduledata.text/pcHeader.textStart nameOff int32 // function name, as index into moduledata.funcnametab. args int32 // in/out args size @@ -103,8 +100,7 @@ type _func struct { npcdata uint32 cuOffset uint32 // runtime.cutab offset of this function's CU funcID uint8 // set for certain special runtime functions - flag uint8 - _ [1]byte // pad + _ [2]byte // pad nfuncdata uint8 // // The end of the struct is followed immediately by two variable-length @@ -131,8 +127,8 @@ type _func struct { } type funcTab struct { - entry uint32 - funcoff uint32 + entry uintptr + funcoff uintptr } type bitVector struct { @@ -170,6 +166,11 @@ type findfuncbucket struct { _SUBBUCKETS [16]byte } + +type compilationUnit struct { + fileNames []string +} + // func name table format: // nameOff[0] -> namePartA namePartB namePartC \x00 // nameOff[1] -> namePartA namePartB namePartC \x00 @@ -192,10 +193,6 @@ func makeFuncnameTab(funcs []Func) (tab []byte, offs []int32) { return } -type compilationUnit struct { - fileNames []string -} - // CU table format: // cuOffsets[0] -> filetabOffset[0] filetabOffset[1] ... filetabOffset[len(CUs[0].fileNames)-1] // cuOffsets[1] -> filetabOffset[len(CUs[0].fileNames)] ... filetabOffset[len(CUs[0].fileNames) + len(CUs[1].fileNames)-1] @@ -266,68 +263,76 @@ func writeFuncdata(out *[]byte, funcs []Func) (fstart int, funcdataOffs [][]uint return } -func makeFtab(funcs []_func, lastFuncSize uint32) (ftab []funcTab) { +func makeFtab(funcs []_func, lastFuncSize uint32) (ftab []funcTab, pclntabSize int64, startLocations []uint32) { // Allocate space for the pc->func table. This structure consists of a pc offset // and an offset to the func structure. After that, we have a single pc // value that marks the end of the last function in the binary. - var size int64 = int64(len(funcs)*2*4 + 4) - var startLocations = make([]uint32, len(funcs)) + pclntabSize = int64(len(funcs)*2*int(_PtrSize) + int(_PtrSize)) + startLocations = make([]uint32, len(funcs)) for i, f := range funcs { - size = rnd(size, int64(_PtrSize)) + pclntabSize = rnd(pclntabSize, int64(_PtrSize)) //writePCToFunc - startLocations[i] = uint32(size) - size += int64(uint8(_FUNC_SIZE)+f.nfuncdata*4+uint8(f.npcdata)*4) + startLocations[i] = uint32(pclntabSize) + pclntabSize += int64(uint8(_FUNC_SIZE) + f.nfuncdata*_PtrSize + uint8(f.npcdata)*4) } - ftab = make([]funcTab, 0, len(funcs)+1) // write a map of pc->func info offsets for i, f := range funcs { - ftab = append(ftab, funcTab{uint32(f.entryOff), uint32(startLocations[i])}) + ftab = append(ftab, funcTab{uintptr(f.entry), uintptr(startLocations[i])}) } // Final entry of table is just end pc offset. lastFunc := funcs[len(funcs)-1] - ftab = append(ftab, funcTab{uint32(lastFunc.entryOff + lastFuncSize), 0}) + ftab = append(ftab, funcTab{lastFunc.entry + uintptr(lastFuncSize), 0}) return } // Pcln table format: [...]funcTab + [...]_Func -func makePclntable(funcs []_func, lastFuncSize uint32, pcdataOffs [][]uint32, funcdataOffs [][]uint32) (pclntab []byte) { - // Allocate space for the pc->func table. This structure consists of a pc offset - // and an offset to the func structure. After that, we have a single pc - // value that marks the end of the last function in the binary. - var size int64 = int64(len(funcs)*2*4 + 4) - var startLocations = make([]uint32, len(funcs)) - for i := range funcs { - size = rnd(size, int64(_PtrSize)) - //writePCToFunc - startLocations[i] = uint32(size) - size += int64(int(_FUNC_SIZE)+len(funcdataOffs[i])*4+len(pcdataOffs[i])*4) - } - +func makePclntable(size int64, startLocations []uint32, funcs []_func, lastFuncSize uint32, pcdataOffs [][]uint32, funcdataAddr uintptr, funcdataOffs [][]uint32) (pclntab []byte) { pclntab = make([]byte, size, size) // write a map of pc->func info offsets offs := 0 for i, f := range funcs { - byteOrder.PutUint32(pclntab[offs:offs+4], uint32(f.entryOff)) - byteOrder.PutUint32(pclntab[offs+4:offs+8], uint32(startLocations[i])) - offs += 8 + byteOrder.PutUint64(pclntab[offs:offs+8], uint64(f.entry)) + byteOrder.PutUint64(pclntab[offs+8:offs+16], uint64(startLocations[i])) + offs += 16 } // Final entry of table is just end pc offset. lastFunc := funcs[len(funcs)-1] - byteOrder.PutUint32(pclntab[offs:offs+4], uint32(lastFunc.entryOff+lastFuncSize)) + byteOrder.PutUint64(pclntab[offs:offs+8], uint64(lastFunc.entry)+uint64(lastFuncSize)) + offs += 8 // write func info table for i, f := range funcs { off := startLocations[i] // write _func structure to pclntab - fb := rt.BytesFrom(unsafe.Pointer(&f), int(_FUNC_SIZE), int(_FUNC_SIZE)) - copy(pclntab[off:off+uint32(_FUNC_SIZE)], fb) - off += uint32(_FUNC_SIZE) + byteOrder.PutUint64(pclntab[off:off+8], uint64(f.entry)) + off += 8 + byteOrder.PutUint32(pclntab[off:off+4], uint32(f.nameOff)) + off += 4 + byteOrder.PutUint32(pclntab[off:off+4], uint32(f.args)) + off += 4 + byteOrder.PutUint32(pclntab[off:off+4], uint32(f.deferreturn)) + off += 4 + byteOrder.PutUint32(pclntab[off:off+4], uint32(f.pcsp)) + off += 4 + byteOrder.PutUint32(pclntab[off:off+4], uint32(f.pcfile)) + off += 4 + byteOrder.PutUint32(pclntab[off:off+4], uint32(f.pcln)) + off += 4 + byteOrder.PutUint32(pclntab[off:off+4], uint32(f.npcdata)) + off += 4 + byteOrder.PutUint32(pclntab[off:off+4], uint32(f.cuOffset)) + off += 4 + pclntab[off] = f.funcID + // NOTICE: _[2]byte alignment + off += 3 + pclntab[off] = f.nfuncdata + off += 1 // NOTICE: _func.pcdata always starts from PcUnsafePoint, which is index 3 for j := 3; j < len(pcdataOffs[i]); j++ { @@ -335,12 +340,17 @@ func makePclntable(funcs []_func, lastFuncSize uint32, pcdataOffs [][]uint32, fu off += 4 } + off = uint32(rnd(int64(off), int64(_PtrSize))) + // funcdata refs as offsets from gofunc for _, funcdata := range funcdataOffs[i] { - byteOrder.PutUint32(pclntab[off:off+4], uint32(funcdata)) - off += 4 + if funcdata == _INVALID_FUNCDATA_OFFSET { + byteOrder.PutUint64(pclntab[off:off+8], 0) + } else { + byteOrder.PutUint64(pclntab[off:off+8], uint64(funcdataAddr)+uint64(funcdata)) + } + off += 8 } - } return @@ -364,14 +374,14 @@ func writeFindfunctab(out *[]byte, ftab []funcTab) (start int) { tab := make([]findfuncbucket, 0, nbuckets) var s, e = 0, 0 for i := 0; i<int(nbuckets); i++ { - var pc = min + uint32((i+1)*_BUCKETSIZE) + var pc = min + uintptr((i+1)*_BUCKETSIZE) // find the end func of the bucket for ; e < len(ftab)-1 && ftab[e+1].entry <= pc; e++ {} // store the start func of the bucket var fb = findfuncbucket{idx: uint32(s)} for j := 0; j<_SUBBUCKETS && (i*_SUBBUCKETS+j)<int(n); j++ { - pc = min + uint32(i*_BUCKETSIZE) + uint32((j+1)*_SUB_BUCKETSIZE) + pc = min + uintptr(i*_BUCKETSIZE) + uintptr((j+1)*_SUB_BUCKETSIZE) var ss = s // find the end func of the subbucket for ; ss < len(ftab)-1 && ftab[ss+1].entry <= pc; ss++ {} @@ -408,9 +418,19 @@ func makeModuledata(name string, filenames []string, funcs []Func, text []byte) funcnametab, nameOffs := makeFuncnameTab(funcs) mod.funcnametab = funcnametab + // mmap() text and funcdata segements + p := os.Getpagesize() + size := int(rnd(int64(len(text)), int64(p))) + addr := mmap(size) + // copy the machine code + s := rt.BytesFrom(unsafe.Pointer(addr), len(text), size) + copy(s, text) + // make it executable + mprotect(addr, size) + // make pcdata table // NOTICE: _func only use offset to index pcdata, thus no need mmap() pcdata - pctab, pcdataOffs, _funcs := makePctab(funcs, cuOffs, nameOffs) + pctab, pcdataOffs, _funcs := makePctab(funcs, addr, cuOffs, nameOffs) mod.pctab = pctab // write func data @@ -421,39 +441,29 @@ func makeModuledata(name string, filenames []string, funcs []Func, text []byte) // make pc->func (binary search) func table lastFuncsize := funcs[len(funcs)-1].TextSize - ftab := makeFtab(_funcs, lastFuncsize) + ftab, pclntSize, startLocations := makeFtab(_funcs, lastFuncsize) mod.ftab = ftab // write pc->func (modmap) findfunc table ffstart := writeFindfunctab(&cache, ftab) + // cache funcdata and findfuncbucket + moduleCache.Lock() + moduleCache.m[mod] = cache + moduleCache.Unlock() + mod.findfunctab = uintptr(rt.IndexByte(cache, ffstart)) + funcdataAddr := uintptr(rt.IndexByte(cache, fstart)) + // make pclnt table - pclntab := makePclntable(_funcs, lastFuncsize, pcdataOffs, funcdataOffs) + pclntab := makePclntable(pclntSize, startLocations, _funcs, lastFuncsize, pcdataOffs, funcdataAddr, funcdataOffs) mod.pclntable = pclntab - // mmap() text and funcdata segements - p := os.Getpagesize() - size := int(rnd(int64(len(text)), int64(p))) - addr := mmap(size) - // copy the machine code - s := rt.BytesFrom(unsafe.Pointer(addr), len(text), size) - copy(s, text) - // make it executable - mprotect(addr, size) - // assign addresses mod.text = addr mod.etext = addr + uintptr(size) mod.minpc = addr mod.maxpc = addr + uintptr(len(text)) - // cache funcdata and findfuncbucket - moduleCache.Lock() - moduleCache.m[mod] = cache - moduleCache.Unlock() - mod.gofunc = uintptr(unsafe.Pointer(&cache[fstart])) - mod.findfunctab = uintptr(unsafe.Pointer(&cache[ffstart])) - // make pc header mod.pcHeader = &pcHeader { magic : _Magic, @@ -461,7 +471,6 @@ func makeModuledata(name string, filenames []string, funcs []Func, text []byte) ptrSize : _PtrSize, nfunc : len(funcs), nfiles: uint(len(cu)), - textStart: mod.text, funcnameOffset: getOffsetOf(moduledata{}, "funcnametab"), cuOffset: getOffsetOf(moduledata{}, "cutab"), filetabOffset: getOffsetOf(moduledata{}, "filetab"), @@ -478,7 +487,7 @@ func makeModuledata(name string, filenames []string, funcs []Func, text []byte) // makePctab generates pcdelta->valuedelta tables for functions, // and returns the table and the entry offset of every kind pcdata in the table. -func makePctab(funcs []Func, cuOffset []uint32, nameOffset []int32) (pctab []byte, pcdataOffs [][]uint32, _funcs []_func) { +func makePctab(funcs []Func, addr uintptr, cuOffset []uint32, nameOffset []int32) (pctab []byte, pcdataOffs [][]uint32, _funcs []_func) { _funcs = make([]_func, len(funcs)) // Pctab offsets of 0 are considered invalid in the runtime. We respect @@ -523,7 +532,7 @@ func makePctab(funcs []Func, cuOffset []uint32, nameOffset []int32) (pctab []byt writer(f.PcInlTreeIndex) writer(f.PcArgLiveIndex) - _f.entryOff = f.EntryOff + _f.entry = addr + uintptr(f.EntryOff) _f.nameOff = nameOffset[i] _f.args = f.ArgsSize _f.deferreturn = f.DeferReturn @@ -531,7 +540,6 @@ func makePctab(funcs []Func, cuOffset []uint32, nameOffset []int32) (pctab []byt _f.npcdata = uint32(_N_PCDATA) _f.cuOffset = cuOffset[i] _f.funcID = f.ID - _f.flag = f.Flag _f.nfuncdata = uint8(_N_FUNCDATA) } diff --git a/vendor/github.com/bytedance/sonic/loader/funcdata_go116.go b/vendor/github.com/bytedance/sonic/loader/funcdata_go116.go new file mode 100644 index 000000000..508268e7d --- /dev/null +++ b/vendor/github.com/bytedance/sonic/loader/funcdata_go116.go @@ -0,0 +1,549 @@ +//go:build go1.16 && !go1.18 +// +build go1.16,!go1.18 + +/* + * Copyright 2021 ByteDance Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package loader + +import ( + `encoding` + `os` + `unsafe` + + `github.com/bytedance/sonic/internal/rt` +) + +const ( + _Magic uint32 = 0xfffffffa +) + +type pcHeader struct { + magic uint32 // 0xFFFFFFF0 + pad1, pad2 uint8 // 0,0 + minLC uint8 // min instruction size + ptrSize uint8 // size of a ptr in bytes + nfunc int // number of functions in the module + nfiles uint // number of entries in the file tab + funcnameOffset uintptr // offset to the funcnametab variable from pcHeader + cuOffset uintptr // offset to the cutab variable from pcHeader + filetabOffset uintptr // offset to the filetab variable from pcHeader + pctabOffset uintptr // offset to the pctab variable from pcHeader + pclnOffset uintptr // offset to the pclntab variable from pcHeader +} + +type moduledata struct { + pcHeader *pcHeader + funcnametab []byte + cutab []uint32 + filetab []byte + pctab []byte + pclntable []byte + ftab []funcTab + findfunctab uintptr + minpc, maxpc uintptr // first func address, last func address + last func size + + text, etext uintptr // start/end of text, (etext-text) must be greater than MIN_FUNC + noptrdata, enoptrdata uintptr + data, edata uintptr + bss, ebss uintptr + noptrbss, enoptrbss uintptr + end, gcdata, gcbss uintptr + types, etypes uintptr + + textsectmap []textSection // see runtime/symtab.go: textAddr() + typelinks []int32 // offsets from types + itablinks []*rt.GoItab + + ptab []ptabEntry + + pluginpath string + pkghashes []modulehash + + modulename string + modulehashes []modulehash + + hasmain uint8 // 1 if module contains the main function, 0 otherwise + + gcdatamask, gcbssmask bitVector + + typemap map[int32]*rt.GoType // offset to *_rtype in previous module + + bad bool // module failed to load and should be ignored + + next *moduledata +} + +type _func struct { + entry uintptr // start pc, as offset from moduledata.text/pcHeader.textStart + nameOff int32 // function name, as index into moduledata.funcnametab. + + args int32 // in/out args size + deferreturn uint32 // offset of start of a deferreturn call instruction from entry, if any. + + pcsp uint32 + pcfile uint32 + pcln uint32 + npcdata uint32 + cuOffset uint32 // runtime.cutab offset of this function's CU + funcID uint8 // set for certain special runtime functions + _ [2]byte // pad + nfuncdata uint8 // + + // The end of the struct is followed immediately by two variable-length + // arrays that reference the pcdata and funcdata locations for this + // function. + + // pcdata contains the offset into moduledata.pctab for the start of + // that index's table. e.g., + // &moduledata.pctab[_func.pcdata[_PCDATA_UnsafePoint]] is the start of + // the unsafe point table. + // + // An offset of 0 indicates that there is no table. + // + // pcdata [npcdata]uint32 + + // funcdata contains the offset past moduledata.gofunc which contains a + // pointer to that index's funcdata. e.g., + // *(moduledata.gofunc + _func.funcdata[_FUNCDATA_ArgsPointerMaps]) is + // the argument pointer map. + // + // An offset of ^uint32(0) indicates that there is no entry. + // + // funcdata [nfuncdata]uint32 +} + +type funcTab struct { + entry uintptr + funcoff uintptr +} + +type bitVector struct { + n int32 // # of bits + bytedata *uint8 +} + +type ptabEntry struct { + name int32 + typ int32 +} + +type textSection struct { + vaddr uintptr // prelinked section vaddr + end uintptr // vaddr + section length + baseaddr uintptr // relocated section address +} + +type modulehash struct { + modulename string + linktimehash string + runtimehash *string +} + +// findfuncbucket is an array of these structures. +// Each bucket represents 4096 bytes of the text segment. +// Each subbucket represents 256 bytes of the text segment. +// To find a function given a pc, locate the bucket and subbucket for +// that pc. Add together the idx and subbucket value to obtain a +// function index. Then scan the functab array starting at that +// index to find the target function. +// This table uses 20 bytes for every 4096 bytes of code, or ~0.5% overhead. +type findfuncbucket struct { + idx uint32 + _SUBBUCKETS [16]byte +} + + +type compilationUnit struct { + fileNames []string +} + +// func name table format: +// nameOff[0] -> namePartA namePartB namePartC \x00 +// nameOff[1] -> namePartA namePartB namePartC \x00 +// ... +func makeFuncnameTab(funcs []Func) (tab []byte, offs []int32) { + offs = make([]int32, len(funcs)) + offset := 0 + + for i, f := range funcs { + offs[i] = int32(offset) + + a, b, c := funcNameParts(f.Name) + tab = append(tab, a...) + tab = append(tab, b...) + tab = append(tab, c...) + tab = append(tab, 0) + offset += len(a) + len(b) + len(c) + 1 + } + + return +} + +// CU table format: +// cuOffsets[0] -> filetabOffset[0] filetabOffset[1] ... filetabOffset[len(CUs[0].fileNames)-1] +// cuOffsets[1] -> filetabOffset[len(CUs[0].fileNames)] ... filetabOffset[len(CUs[0].fileNames) + len(CUs[1].fileNames)-1] +// ... +// +// file name table format: +// filetabOffset[0] -> CUs[0].fileNames[0] \x00 +// ... +// filetabOffset[len(CUs[0]-1)] -> CUs[0].fileNames[len(CUs[0].fileNames)-1] \x00 +// ... +// filetabOffset[SUM(CUs,fileNames)-1] -> CUs[len(CU)-1].fileNames[len(CUs[len(CU)-1].fileNames)-1] \x00 +func makeFilenametab(cus []compilationUnit) (cutab []uint32, filetab []byte, cuOffsets []uint32) { + cuOffsets = make([]uint32, len(cus)) + cuOffset := 0 + fileOffset := 0 + + for i, cu := range cus { + cuOffsets[i] = uint32(cuOffset) + + for _, name := range cu.fileNames { + cutab = append(cutab, uint32(fileOffset)) + + fileOffset += len(name) + 1 + filetab = append(filetab, name...) + filetab = append(filetab, 0) + } + + cuOffset += len(cu.fileNames) + } + + return +} + +func writeFuncdata(out *[]byte, funcs []Func) (fstart int, funcdataOffs [][]uint32) { + fstart = len(*out) + *out = append(*out, byte(0)) + offs := uint32(1) + + funcdataOffs = make([][]uint32, len(funcs)) + for i, f := range funcs { + + var writer = func(fd encoding.BinaryMarshaler) { + var ab []byte + var err error + if fd != nil { + ab, err = fd.MarshalBinary() + if err != nil { + panic(err) + } + funcdataOffs[i] = append(funcdataOffs[i], offs) + } else { + ab = []byte{0} + funcdataOffs[i] = append(funcdataOffs[i], _INVALID_FUNCDATA_OFFSET) + } + *out = append(*out, ab...) + offs += uint32(len(ab)) + } + + writer(f.ArgsPointerMaps) + writer(f.LocalsPointerMaps) + writer(f.StackObjects) + writer(f.InlTree) + writer(f.OpenCodedDeferInfo) + writer(f.ArgInfo) + writer(f.ArgLiveInfo) + writer(f.WrapInfo) + } + return +} + +func makeFtab(funcs []_func, lastFuncSize uint32) (ftab []funcTab, pclntabSize int64, startLocations []uint32) { + // Allocate space for the pc->func table. This structure consists of a pc offset + // and an offset to the func structure. After that, we have a single pc + // value that marks the end of the last function in the binary. + pclntabSize = int64(len(funcs)*2*int(_PtrSize) + int(_PtrSize)) + startLocations = make([]uint32, len(funcs)) + for i, f := range funcs { + pclntabSize = rnd(pclntabSize, int64(_PtrSize)) + //writePCToFunc + startLocations[i] = uint32(pclntabSize) + pclntabSize += int64(uint8(_FUNC_SIZE) + f.nfuncdata*_PtrSize + uint8(f.npcdata)*4) + } + ftab = make([]funcTab, 0, len(funcs)+1) + + // write a map of pc->func info offsets + for i, f := range funcs { + ftab = append(ftab, funcTab{uintptr(f.entry), uintptr(startLocations[i])}) + } + + // Final entry of table is just end pc offset. + lastFunc := funcs[len(funcs)-1] + ftab = append(ftab, funcTab{lastFunc.entry + uintptr(lastFuncSize), 0}) + + return +} + +// Pcln table format: [...]funcTab + [...]_Func +func makePclntable(size int64, startLocations []uint32, funcs []_func, lastFuncSize uint32, pcdataOffs [][]uint32, funcdataAddr uintptr, funcdataOffs [][]uint32) (pclntab []byte) { + pclntab = make([]byte, size, size) + + // write a map of pc->func info offsets + offs := 0 + for i, f := range funcs { + byteOrder.PutUint64(pclntab[offs:offs+8], uint64(f.entry)) + byteOrder.PutUint64(pclntab[offs+8:offs+16], uint64(startLocations[i])) + offs += 16 + } + // Final entry of table is just end pc offset. + lastFunc := funcs[len(funcs)-1] + byteOrder.PutUint64(pclntab[offs:offs+8], uint64(lastFunc.entry)+uint64(lastFuncSize)) + offs += 8 + + // write func info table + for i, f := range funcs { + off := startLocations[i] + + // write _func structure to pclntab + byteOrder.PutUint64(pclntab[off:off+8], uint64(f.entry)) + off += 8 + byteOrder.PutUint32(pclntab[off:off+4], uint32(f.nameOff)) + off += 4 + byteOrder.PutUint32(pclntab[off:off+4], uint32(f.args)) + off += 4 + byteOrder.PutUint32(pclntab[off:off+4], uint32(f.deferreturn)) + off += 4 + byteOrder.PutUint32(pclntab[off:off+4], uint32(f.pcsp)) + off += 4 + byteOrder.PutUint32(pclntab[off:off+4], uint32(f.pcfile)) + off += 4 + byteOrder.PutUint32(pclntab[off:off+4], uint32(f.pcln)) + off += 4 + byteOrder.PutUint32(pclntab[off:off+4], uint32(f.npcdata)) + off += 4 + byteOrder.PutUint32(pclntab[off:off+4], uint32(f.cuOffset)) + off += 4 + pclntab[off] = f.funcID + // NOTICE: _[2]byte alignment + off += 3 + pclntab[off] = f.nfuncdata + off += 1 + + // NOTICE: _func.pcdata always starts from PcUnsafePoint, which is index 3 + for j := 3; j < len(pcdataOffs[i]); j++ { + byteOrder.PutUint32(pclntab[off:off+4], uint32(pcdataOffs[i][j])) + off += 4 + } + + off = uint32(rnd(int64(off), int64(_PtrSize))) + + // funcdata refs as offsets from gofunc + for _, funcdata := range funcdataOffs[i] { + if funcdata == _INVALID_FUNCDATA_OFFSET { + byteOrder.PutUint64(pclntab[off:off+8], 0) + } else { + byteOrder.PutUint64(pclntab[off:off+8], uint64(funcdataAddr)+uint64(funcdata)) + } + off += 8 + } + } + + return +} + +// findfunc table used to map pc to belonging func, +// returns the index in the func table. +// +// All text section are divided into buckets sized _BUCKETSIZE(4K): +// every bucket is divided into _SUBBUCKETS sized _SUB_BUCKETSIZE(64), +// and it has a base idx to plus the offset stored in jth subbucket. +// see findfunc() in runtime/symtab.go +func writeFindfunctab(out *[]byte, ftab []funcTab) (start int) { + start = len(*out) + + max := ftab[len(ftab)-1].entry + min := ftab[0].entry + nbuckets := (max - min + _BUCKETSIZE - 1) / _BUCKETSIZE + n := (max - min + _SUB_BUCKETSIZE - 1) / _SUB_BUCKETSIZE + + tab := make([]findfuncbucket, 0, nbuckets) + var s, e = 0, 0 + for i := 0; i<int(nbuckets); i++ { + var pc = min + uintptr((i+1)*_BUCKETSIZE) + // find the end func of the bucket + for ; e < len(ftab)-1 && ftab[e+1].entry <= pc; e++ {} + // store the start func of the bucket + var fb = findfuncbucket{idx: uint32(s)} + + for j := 0; j<_SUBBUCKETS && (i*_SUBBUCKETS+j)<int(n); j++ { + pc = min + uintptr(i*_BUCKETSIZE) + uintptr((j+1)*_SUB_BUCKETSIZE) + var ss = s + // find the end func of the subbucket + for ; ss < len(ftab)-1 && ftab[ss+1].entry <= pc; ss++ {} + // store the start func of the subbucket + fb._SUBBUCKETS[j] = byte(uint32(s) - fb.idx) + s = ss + } + s = e + tab = append(tab, fb) + } + + // write findfuncbucket + if len(tab) > 0 { + size := int(unsafe.Sizeof(findfuncbucket{}))*len(tab) + *out = append(*out, rt.BytesFrom(unsafe.Pointer(&tab[0]), size, size)...) + } + return +} + +func makeModuledata(name string, filenames []string, funcs []Func, text []byte) (mod *moduledata) { + mod = new(moduledata) + mod.modulename = name + + // make filename table + cu := make([]string, 0, len(filenames)) + for _, f := range filenames { + cu = append(cu, f) + } + cutab, filetab, cuOffs := makeFilenametab([]compilationUnit{{cu}}) + mod.cutab = cutab + mod.filetab = filetab + + // make funcname table + funcnametab, nameOffs := makeFuncnameTab(funcs) + mod.funcnametab = funcnametab + + // mmap() text and funcdata segements + p := os.Getpagesize() + size := int(rnd(int64(len(text)), int64(p))) + addr := mmap(size) + // copy the machine code + s := rt.BytesFrom(unsafe.Pointer(addr), len(text), size) + copy(s, text) + // make it executable + mprotect(addr, size) + + // make pcdata table + // NOTICE: _func only use offset to index pcdata, thus no need mmap() pcdata + pctab, pcdataOffs, _funcs := makePctab(funcs, addr, cuOffs, nameOffs) + mod.pctab = pctab + + // write func data + // NOTICE: _func use mod.gofunc+offset to directly point funcdata, thus need cache funcdata + // TODO: estimate accurate capacity + cache := make([]byte, 0, len(funcs)*int(_PtrSize)) + fstart, funcdataOffs := writeFuncdata(&cache, funcs) + + // make pc->func (binary search) func table + lastFuncsize := funcs[len(funcs)-1].TextSize + ftab, pclntSize, startLocations := makeFtab(_funcs, lastFuncsize) + mod.ftab = ftab + + // write pc->func (modmap) findfunc table + ffstart := writeFindfunctab(&cache, ftab) + + // cache funcdata and findfuncbucket + moduleCache.Lock() + moduleCache.m[mod] = cache + moduleCache.Unlock() + mod.findfunctab = uintptr(rt.IndexByte(cache, ffstart)) + funcdataAddr := uintptr(rt.IndexByte(cache, fstart)) + + // make pclnt table + pclntab := makePclntable(pclntSize, startLocations, _funcs, lastFuncsize, pcdataOffs, funcdataAddr, funcdataOffs) + mod.pclntable = pclntab + + // assign addresses + mod.text = addr + mod.etext = addr + uintptr(size) + mod.minpc = addr + mod.maxpc = addr + uintptr(len(text)) + + // make pc header + mod.pcHeader = &pcHeader { + magic : _Magic, + minLC : _MinLC, + ptrSize : _PtrSize, + nfunc : len(funcs), + nfiles: uint(len(cu)), + funcnameOffset: getOffsetOf(moduledata{}, "funcnametab"), + cuOffset: getOffsetOf(moduledata{}, "cutab"), + filetabOffset: getOffsetOf(moduledata{}, "filetab"), + pctabOffset: getOffsetOf(moduledata{}, "pctab"), + pclnOffset: getOffsetOf(moduledata{}, "pclntable"), + } + + // sepecial case: gcdata and gcbss must by non-empty + mod.gcdata = uintptr(unsafe.Pointer(&emptyByte)) + mod.gcbss = uintptr(unsafe.Pointer(&emptyByte)) + + return +} + +// makePctab generates pcdelta->valuedelta tables for functions, +// and returns the table and the entry offset of every kind pcdata in the table. +func makePctab(funcs []Func, addr uintptr, cuOffset []uint32, nameOffset []int32) (pctab []byte, pcdataOffs [][]uint32, _funcs []_func) { + _funcs = make([]_func, len(funcs)) + + // Pctab offsets of 0 are considered invalid in the runtime. We respect + // that by just padding a single byte at the beginning of runtime.pctab, + // that way no real offsets can be zero. + pctab = make([]byte, 1, 12*len(funcs)+1) + pcdataOffs = make([][]uint32, len(funcs)) + + for i, f := range funcs { + _f := &_funcs[i] + + var writer = func(pc *Pcdata) { + var ab []byte + var err error + if pc != nil { + ab, err = pc.MarshalBinary() + if err != nil { + panic(err) + } + pcdataOffs[i] = append(pcdataOffs[i], uint32(len(pctab))) + } else { + ab = []byte{0} + pcdataOffs[i] = append(pcdataOffs[i], _PCDATA_INVALID_OFFSET) + } + pctab = append(pctab, ab...) + } + + if f.Pcsp != nil { + _f.pcsp = uint32(len(pctab)) + } + writer(f.Pcsp) + if f.Pcfile != nil { + _f.pcfile = uint32(len(pctab)) + } + writer(f.Pcfile) + if f.Pcline != nil { + _f.pcln = uint32(len(pctab)) + } + writer(f.Pcline) + writer(f.PcUnsafePoint) + writer(f.PcStackMapIndex) + writer(f.PcInlTreeIndex) + writer(f.PcArgLiveIndex) + + _f.entry = addr + uintptr(f.EntryOff) + _f.nameOff = nameOffset[i] + _f.args = f.ArgsSize + _f.deferreturn = f.DeferReturn + // NOTICE: _func.pcdata is always as [PCDATA_UnsafePoint(0) : PCDATA_ArgLiveIndex(3)] + _f.npcdata = uint32(_N_PCDATA) + _f.cuOffset = cuOffset[i] + _f.funcID = f.ID + _f.nfuncdata = uint8(_N_FUNCDATA) + } + + return +} + +func registerFunction(name string, pc uintptr, textSize uintptr, fp int, args int, size uintptr, argptrs uintptr, localptrs uintptr) {}
\ No newline at end of file diff --git a/vendor/github.com/bytedance/sonic/loader/loader_go115.go b/vendor/github.com/bytedance/sonic/loader/loader_go115.go index 1e44b36a6..a1d4d7892 100644 --- a/vendor/github.com/bytedance/sonic/loader/loader_go115.go +++ b/vendor/github.com/bytedance/sonic/loader/loader_go115.go @@ -1,5 +1,5 @@ -//go:build go1.15 && !go1.18 -// +build go1.15,!go1.18 +//go:build go1.15 && !go1.16 +// +build go1.15,!go1.16 /* * Copyright 2021 ByteDance Inc. @@ -20,14 +20,9 @@ package loader import ( - `github.com/bytedance/sonic/internal/loader` ) func (self Loader) LoadOne(text []byte, funcName string, frameSize int, argSize int, argStackmap []bool, localStackmap []bool) Function { return Function(loader.Loader(text).Load(funcName, frameSize, argSize, argStackmap, localStackmap)) -} - -func Load(modulename string, filenames []string, funcs []Func, text []byte) (out []Function) { - panic("not implemented") }
\ No newline at end of file diff --git a/vendor/github.com/bytedance/sonic/loader/loader_go118.go b/vendor/github.com/bytedance/sonic/loader/loader_go116.go index 9a0fe4843..ea30ec9a5 100644 --- a/vendor/github.com/bytedance/sonic/loader/loader_go118.go +++ b/vendor/github.com/bytedance/sonic/loader/loader_go116.go @@ -1,5 +1,5 @@ -//go:build go1.18 && !go1.21 -// +build go1.18,!go1.21 +//go:build go1.16 && !go1.21 +// +build go1.16,!go1.21 /* * Copyright 2021 ByteDance Inc. diff --git a/vendor/github.com/bytedance/sonic/loader/stubs.go b/vendor/github.com/bytedance/sonic/loader/stubs.go index 71439c4b7..8377649b7 100644 --- a/vendor/github.com/bytedance/sonic/loader/stubs.go +++ b/vendor/github.com/bytedance/sonic/loader/stubs.go @@ -1,12 +1,12 @@ /** * 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. @@ -17,16 +17,21 @@ package loader import ( - _ `unsafe` + `sync` + _ `unsafe` ) //go:linkname lastmoduledatap runtime.lastmoduledatap //goland:noinspection GoUnusedGlobalVariable var lastmoduledatap *moduledata +var moduledataMux sync.Mutex + func registerModule(mod *moduledata) { + moduledataMux.Lock() lastmoduledatap.next = mod lastmoduledatap = mod + moduledataMux.Unlock() } //go:linkname moduledataverify1 runtime.moduledataverify1 diff --git a/vendor/github.com/bytedance/sonic/option/option.go b/vendor/github.com/bytedance/sonic/option/option.go index 359f99206..71527cdf0 100644 --- a/vendor/github.com/bytedance/sonic/option/option.go +++ b/vendor/github.com/bytedance/sonic/option/option.go @@ -16,6 +16,14 @@ package option +var ( + // DefaultDecoderBufferSize is the initial buffer size of StreamDecoder + DefaultDecoderBufferSize uint = 128 * 1024 + + // DefaultEncoderBufferSize is the initial buffer size of Encoder + DefaultEncoderBufferSize uint = 128 * 1024 +) + // CompileOptions includes all options for encoder or decoder compiler. type CompileOptions struct { // the maximum depth for compilation inline diff --git a/vendor/github.com/bytedance/sonic/other-langs.png b/vendor/github.com/bytedance/sonic/other-langs.png Binary files differdeleted file mode 100644 index 8aae25453..000000000 --- a/vendor/github.com/bytedance/sonic/other-langs.png +++ /dev/null diff --git a/vendor/github.com/bytedance/sonic/unquote/unquote.go b/vendor/github.com/bytedance/sonic/unquote/unquote.go index 0ffdaac7d..23fca736e 100644 --- a/vendor/github.com/bytedance/sonic/unquote/unquote.go +++ b/vendor/github.com/bytedance/sonic/unquote/unquote.go @@ -18,6 +18,7 @@ package unquote import ( `unsafe` + `runtime` `github.com/bytedance/sonic/internal/native` `github.com/bytedance/sonic/internal/native/types` @@ -43,7 +44,8 @@ func intoBytesUnsafe(s string, m *[]byte) types.ParsingError { pos := -1 slv := (*rt.GoSlice)(unsafe.Pointer(m)) str := (*rt.GoString)(unsafe.Pointer(&s)) - ret := native.Unquote(str.Ptr, str.Len, slv.Ptr, &pos, 0) + /* unquote as the default configuration, replace invalid unicode with \ufffd */ + ret := native.Unquote(str.Ptr, str.Len, slv.Ptr, &pos, types.F_UNICODE_REPLACE) /* check for errors */ if ret < 0 { @@ -52,5 +54,6 @@ func intoBytesUnsafe(s string, m *[]byte) types.ParsingError { /* update the length */ slv.Len = ret + runtime.KeepAlive(s) return 0 } diff --git a/vendor/github.com/gin-gonic/gin/.golangci.yml b/vendor/github.com/gin-gonic/gin/.golangci.yml index c5e1de388..91dae02c3 100644 --- a/vendor/github.com/gin-gonic/gin/.golangci.yml +++ b/vendor/github.com/gin-gonic/gin/.golangci.yml @@ -19,6 +19,22 @@ linters: - nolintlint - revive - wastedassign + +linters-settings: + gosec: + # To select a subset of rules to run. + # Available rules: https://github.com/securego/gosec#available-rules + # Default: [] - means include all rules + includes: + - G102 + - G106 + - G108 + - G109 + - G111 + - G112 + - G201 + - G203 + issues: exclude-rules: - linters: @@ -37,3 +53,6 @@ issues: - path: _test\.go linters: - gosec # security is not make sense in tests + - linters: + - revive + path: _test\.go diff --git a/vendor/github.com/gin-gonic/gin/CHANGELOG.md b/vendor/github.com/gin-gonic/gin/CHANGELOG.md index cf24ec286..796852055 100644 --- a/vendor/github.com/gin-gonic/gin/CHANGELOG.md +++ b/vendor/github.com/gin-gonic/gin/CHANGELOG.md @@ -1,5 +1,26 @@ # Gin ChangeLog +## Gin v1.9.1 + +### BUG FIXES + +* fix Request.Context() checks [#3512](https://github.com/gin-gonic/gin/pull/3512) + +### SECURITY + +* fix lack of escaping of filename in Content-Disposition [#3556](https://github.com/gin-gonic/gin/pull/3556) + +### ENHANCEMENTS + +* refactor: use bytes.ReplaceAll directly [#3455](https://github.com/gin-gonic/gin/pull/3455) +* convert strings and slices using the officially recommended way [#3344](https://github.com/gin-gonic/gin/pull/3344) +* improve render code coverage [#3525](https://github.com/gin-gonic/gin/pull/3525) + +### DOCS + +* docs: changed documentation link for trusted proxies [#3575](https://github.com/gin-gonic/gin/pull/3575) +* chore: improve linting, testing, and GitHub Actions setup [#3583](https://github.com/gin-gonic/gin/pull/3583) + ## Gin v1.9.0 ### BREAK CHANGES diff --git a/vendor/github.com/gin-gonic/gin/README.md b/vendor/github.com/gin-gonic/gin/README.md index 336155a99..e007bf2fb 100644 --- a/vendor/github.com/gin-gonic/gin/README.md +++ b/vendor/github.com/gin-gonic/gin/README.md @@ -6,7 +6,6 @@ [](https://codecov.io/gh/gin-gonic/gin) [](https://goreportcard.com/report/github.com/gin-gonic/gin) [](https://pkg.go.dev/github.com/gin-gonic/gin?tab=doc) -[](https://gitter.im/gin-gonic/gin?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge) [](https://sourcegraph.com/github.com/gin-gonic/gin?badge) [](https://www.codetriage.com/gin-gonic/gin) [](https://github.com/gin-gonic/gin/releases) @@ -31,7 +30,7 @@ Gin is a web framework written in [Go](https://go.dev/). It features a martini-l ### Prerequisites -- **[Go](https://go.dev/)**: ~~any one of the **three latest major** [releases](https://go.dev/doc/devel/release)~~ (now version **1.16+** is required). +- **[Go](https://go.dev/)**: any one of the **three latest major** [releases](https://go.dev/doc/devel/release) (we test it with these). ### Getting Gin @@ -176,4 +175,4 @@ Awesome project lists using [Gin](https://github.com/gin-gonic/gin) web framewor Gin is the work of hundreds of contributors. We appreciate your help! -Please see [CONTRIBUTING](CONTRIBUTING.md) for details on submitting patches and the contribution workflow.
\ No newline at end of file +Please see [CONTRIBUTING](CONTRIBUTING.md) for details on submitting patches and the contribution workflow. diff --git a/vendor/github.com/gin-gonic/gin/any.go b/vendor/github.com/gin-gonic/gin/any.go deleted file mode 100644 index 42b1ea46f..000000000 --- a/vendor/github.com/gin-gonic/gin/any.go +++ /dev/null @@ -1,10 +0,0 @@ -// Copyright 2022 Gin Core Team. All rights reserved. -// Use of this source code is governed by a MIT style -// license that can be found in the LICENSE file. - -//go:build !go1.18 -// +build !go1.18 - -package gin - -type any = interface{} diff --git a/vendor/github.com/gin-gonic/gin/binding/any.go b/vendor/github.com/gin-gonic/gin/binding/any.go deleted file mode 100644 index d8251a7c2..000000000 --- a/vendor/github.com/gin-gonic/gin/binding/any.go +++ /dev/null @@ -1,10 +0,0 @@ -// Copyright 2022 Gin Core Team. All rights reserved. -// Use of this source code is governed by a MIT style -// license that can be found in the LICENSE file. - -//go:build !go1.18 -// +build !go1.18 - -package binding - -type any = interface{} diff --git a/vendor/github.com/gin-gonic/gin/binding/binding.go b/vendor/github.com/gin-gonic/gin/binding/binding.go index a58924ed3..40948529a 100644 --- a/vendor/github.com/gin-gonic/gin/binding/binding.go +++ b/vendor/github.com/gin-gonic/gin/binding/binding.go @@ -3,7 +3,6 @@ // license that can be found in the LICENSE file. //go:build !nomsgpack -// +build !nomsgpack package binding diff --git a/vendor/github.com/gin-gonic/gin/binding/binding_nomsgpack.go b/vendor/github.com/gin-gonic/gin/binding/binding_nomsgpack.go index 7f6a904ab..93ad8ba30 100644 --- a/vendor/github.com/gin-gonic/gin/binding/binding_nomsgpack.go +++ b/vendor/github.com/gin-gonic/gin/binding/binding_nomsgpack.go @@ -3,7 +3,6 @@ // license that can be found in the LICENSE file. //go:build nomsgpack -// +build nomsgpack package binding diff --git a/vendor/github.com/gin-gonic/gin/binding/json.go b/vendor/github.com/gin-gonic/gin/binding/json.go index 36eb27a34..e21c2ee34 100644 --- a/vendor/github.com/gin-gonic/gin/binding/json.go +++ b/vendor/github.com/gin-gonic/gin/binding/json.go @@ -15,7 +15,7 @@ import ( // EnableDecoderUseNumber is used to call the UseNumber method on the JSON // Decoder instance. UseNumber causes the Decoder to unmarshal a number into an -// interface{} as a Number instead of as a float64. +// any as a Number instead of as a float64. var EnableDecoderUseNumber = false // EnableDecoderDisallowUnknownFields is used to call the DisallowUnknownFields method diff --git a/vendor/github.com/gin-gonic/gin/binding/msgpack.go b/vendor/github.com/gin-gonic/gin/binding/msgpack.go index d1f035e44..22de9b551 100644 --- a/vendor/github.com/gin-gonic/gin/binding/msgpack.go +++ b/vendor/github.com/gin-gonic/gin/binding/msgpack.go @@ -3,7 +3,6 @@ // license that can be found in the LICENSE file. //go:build !nomsgpack -// +build !nomsgpack package binding diff --git a/vendor/github.com/gin-gonic/gin/codecov.yml b/vendor/github.com/gin-gonic/gin/codecov.yml deleted file mode 100644 index c9c9a522d..000000000 --- a/vendor/github.com/gin-gonic/gin/codecov.yml +++ /dev/null @@ -1,5 +0,0 @@ -coverage: - notify: - gitter: - default: - url: https://webhooks.gitter.im/e/d90dcdeeab2f1e357165 diff --git a/vendor/github.com/gin-gonic/gin/context.go b/vendor/github.com/gin-gonic/gin/context.go index 556f8ac9c..420ff1678 100644 --- a/vendor/github.com/gin-gonic/gin/context.go +++ b/vendor/github.com/gin-gonic/gin/context.go @@ -652,7 +652,7 @@ func (c *Context) BindYAML(obj any) error { } // BindTOML is a shortcut for c.MustBindWith(obj, binding.TOML). -func (c *Context) BindTOML(obj interface{}) error { +func (c *Context) BindTOML(obj any) error { return c.MustBindWith(obj, binding.TOML) } @@ -717,7 +717,7 @@ func (c *Context) ShouldBindYAML(obj any) error { } // ShouldBindTOML is a shortcut for c.ShouldBindWith(obj, binding.TOML). -func (c *Context) ShouldBindTOML(obj interface{}) error { +func (c *Context) ShouldBindTOML(obj any) error { return c.ShouldBindWith(obj, binding.TOML) } @@ -995,7 +995,7 @@ func (c *Context) YAML(code int, obj any) { } // TOML serializes the given struct as TOML into the response body. -func (c *Context) TOML(code int, obj interface{}) { +func (c *Context) TOML(code int, obj any) { c.Render(code, render.TOML{Data: obj}) } @@ -1052,11 +1052,17 @@ func (c *Context) FileFromFS(filepath string, fs http.FileSystem) { http.FileServer(fs).ServeHTTP(c.Writer, c.Request) } +var quoteEscaper = strings.NewReplacer("\\", "\\\\", `"`, "\\\"") + +func escapeQuotes(s string) string { + return quoteEscaper.Replace(s) +} + // FileAttachment writes the specified file into the body stream in an efficient way // On the client side, the file will typically be downloaded with the given filename func (c *Context) FileAttachment(filepath, filename string) { if isASCII(filename) { - c.Writer.Header().Set("Content-Disposition", `attachment; filename="`+filename+`"`) + c.Writer.Header().Set("Content-Disposition", `attachment; filename="`+escapeQuotes(filename)+`"`) } else { c.Writer.Header().Set("Content-Disposition", `attachment; filename*=UTF-8''`+url.QueryEscape(filename)) } @@ -1174,9 +1180,16 @@ func (c *Context) SetAccepted(formats ...string) { /***** GOLANG.ORG/X/NET/CONTEXT *****/ /************************************/ +// hasRequestContext returns whether c.Request has Context and fallback. +func (c *Context) hasRequestContext() bool { + hasFallback := c.engine != nil && c.engine.ContextWithFallback + hasRequestContext := c.Request != nil && c.Request.Context() != nil + return hasFallback && hasRequestContext +} + // Deadline returns that there is no deadline (ok==false) when c.Request has no Context. func (c *Context) Deadline() (deadline time.Time, ok bool) { - if !c.engine.ContextWithFallback || c.Request == nil || c.Request.Context() == nil { + if !c.hasRequestContext() { return } return c.Request.Context().Deadline() @@ -1184,7 +1197,7 @@ func (c *Context) Deadline() (deadline time.Time, ok bool) { // Done returns nil (chan which will wait forever) when c.Request has no Context. func (c *Context) Done() <-chan struct{} { - if !c.engine.ContextWithFallback || c.Request == nil || c.Request.Context() == nil { + if !c.hasRequestContext() { return nil } return c.Request.Context().Done() @@ -1192,7 +1205,7 @@ func (c *Context) Done() <-chan struct{} { // Err returns nil when c.Request has no Context. func (c *Context) Err() error { - if !c.engine.ContextWithFallback || c.Request == nil || c.Request.Context() == nil { + if !c.hasRequestContext() { return nil } return c.Request.Context().Err() @@ -1213,7 +1226,7 @@ func (c *Context) Value(key any) any { return val } } - if !c.engine.ContextWithFallback || c.Request == nil || c.Request.Context() == nil { + if !c.hasRequestContext() { return nil } return c.Request.Context().Value(key) diff --git a/vendor/github.com/gin-gonic/gin/context_appengine.go b/vendor/github.com/gin-gonic/gin/context_appengine.go index 931313f61..96b339c48 100644 --- a/vendor/github.com/gin-gonic/gin/context_appengine.go +++ b/vendor/github.com/gin-gonic/gin/context_appengine.go @@ -3,7 +3,6 @@ // license that can be found in the LICENSE file. //go:build appengine -// +build appengine package gin diff --git a/vendor/github.com/gin-gonic/gin/debug.go b/vendor/github.com/gin-gonic/gin/debug.go index cbcedbc98..1fc0cafe1 100644 --- a/vendor/github.com/gin-gonic/gin/debug.go +++ b/vendor/github.com/gin-gonic/gin/debug.go @@ -12,7 +12,7 @@ import ( "strings" ) -const ginSupportMinGoVer = 16 +const ginSupportMinGoVer = 18 // IsDebugging returns true if the framework is running in debug mode. // Use SetMode(gin.ReleaseMode) to disable debug mode. @@ -67,7 +67,7 @@ func getMinVer(v string) (uint64, error) { func debugPrintWARNINGDefault() { if v, e := getMinVer(runtime.Version()); e == nil && v < ginSupportMinGoVer { - debugPrint(`[WARNING] Now Gin requires Go 1.16+. + debugPrint(`[WARNING] Now Gin requires Go 1.18+. `) } diff --git a/vendor/github.com/gin-gonic/gin/deprecated.go b/vendor/github.com/gin-gonic/gin/deprecated.go index fdad85547..9521308f1 100644 --- a/vendor/github.com/gin-gonic/gin/deprecated.go +++ b/vendor/github.com/gin-gonic/gin/deprecated.go @@ -13,7 +13,7 @@ import ( // BindWith binds the passed struct pointer using the specified binding engine. // See the binding package. func (c *Context) BindWith(obj any, b binding.Binding) error { - log.Println(`BindWith(\"interface{}, binding.Binding\") error is going to + log.Println(`BindWith(\"any, binding.Binding\") error is going to be deprecated, please check issue #662 and either use MustBindWith() if you want HTTP 400 to be automatically returned if any error occur, or use ShouldBindWith() if you need to manage the error.`) diff --git a/vendor/github.com/gin-gonic/gin/fs.go b/vendor/github.com/gin-gonic/gin/fs.go index 64274735e..f17d7434d 100644 --- a/vendor/github.com/gin-gonic/gin/fs.go +++ b/vendor/github.com/gin-gonic/gin/fs.go @@ -39,7 +39,7 @@ func (fs onlyFilesFS) Open(name string) (http.File, error) { } // Readdir overrides the http.File default implementation. -func (f neuteredReaddirFile) Readdir(count int) ([]os.FileInfo, error) { +func (f neuteredReaddirFile) Readdir(_ int) ([]os.FileInfo, error) { // this disables directory listing return nil, nil } diff --git a/vendor/github.com/gin-gonic/gin/gin.go b/vendor/github.com/gin-gonic/gin/gin.go index f95e5dda5..ed8b6dad7 100644 --- a/vendor/github.com/gin-gonic/gin/gin.go +++ b/vendor/github.com/gin-gonic/gin/gin.go @@ -515,7 +515,7 @@ func (engine *Engine) RunUnix(file string) (err error) { if engine.isUnsafeTrustedProxies() { debugPrint("[WARNING] You trusted all proxies, this is NOT safe. We recommend you to set a value.\n" + - "Please check https://pkg.go.dev/github.com/gin-gonic/gin#readme-don-t-trust-all-proxies for details.") + "Please check https://github.com/gin-gonic/gin/blob/master/docs/doc.md#dont-trust-all-proxies for details.") } listener, err := net.Listen("unix", file) @@ -538,7 +538,7 @@ func (engine *Engine) RunFd(fd int) (err error) { if engine.isUnsafeTrustedProxies() { debugPrint("[WARNING] You trusted all proxies, this is NOT safe. We recommend you to set a value.\n" + - "Please check https://pkg.go.dev/github.com/gin-gonic/gin#readme-don-t-trust-all-proxies for details.") + "Please check https://github.com/gin-gonic/gin/blob/master/docs/doc.md#dont-trust-all-proxies for details.") } f := os.NewFile(uintptr(fd), fmt.Sprintf("fd@%d", fd)) @@ -559,7 +559,7 @@ func (engine *Engine) RunListener(listener net.Listener) (err error) { if engine.isUnsafeTrustedProxies() { debugPrint("[WARNING] You trusted all proxies, this is NOT safe. We recommend you to set a value.\n" + - "Please check https://pkg.go.dev/github.com/gin-gonic/gin#readme-don-t-trust-all-proxies for details.") + "Please check https://github.com/gin-gonic/gin/blob/master/docs/doc.md#dont-trust-all-proxies for details.") } err = http.Serve(listener, engine.Handler()) diff --git a/vendor/github.com/gin-gonic/gin/internal/bytesconv/bytesconv.go b/vendor/github.com/gin-gonic/gin/internal/bytesconv/bytesconv_1.19.go index 86e4c4d44..669c9c914 100644 --- a/vendor/github.com/gin-gonic/gin/internal/bytesconv/bytesconv.go +++ b/vendor/github.com/gin-gonic/gin/internal/bytesconv/bytesconv_1.19.go @@ -2,6 +2,8 @@ // Use of this source code is governed by a MIT style // license that can be found in the LICENSE file. +//go:build !go1.20 + package bytesconv import ( diff --git a/vendor/github.com/gin-gonic/gin/internal/bytesconv/bytesconv_1.20.go b/vendor/github.com/gin-gonic/gin/internal/bytesconv/bytesconv_1.20.go new file mode 100644 index 000000000..5b6040a6b --- /dev/null +++ b/vendor/github.com/gin-gonic/gin/internal/bytesconv/bytesconv_1.20.go @@ -0,0 +1,23 @@ +// Copyright 2023 Gin Core Team. All rights reserved. +// Use of this source code is governed by a MIT style +// license that can be found in the LICENSE file. + +//go:build go1.20 + +package bytesconv + +import ( + "unsafe" +) + +// StringToBytes converts string to byte slice without a memory allocation. +// For more details, see https://github.com/golang/go/issues/53003#issuecomment-1140276077. +func StringToBytes(s string) []byte { + return unsafe.Slice(unsafe.StringData(s), len(s)) +} + +// BytesToString converts byte slice to string without a memory allocation. +// For more details, see https://github.com/golang/go/issues/53003#issuecomment-1140276077. +func BytesToString(b []byte) string { + return unsafe.String(unsafe.SliceData(b), len(b)) +} diff --git a/vendor/github.com/gin-gonic/gin/internal/json/go_json.go b/vendor/github.com/gin-gonic/gin/internal/json/go_json.go index 23f717265..47c355983 100644 --- a/vendor/github.com/gin-gonic/gin/internal/json/go_json.go +++ b/vendor/github.com/gin-gonic/gin/internal/json/go_json.go @@ -3,7 +3,6 @@ // license that can be found in the LICENSE file. //go:build go_json -// +build go_json package json diff --git a/vendor/github.com/gin-gonic/gin/internal/json/json.go b/vendor/github.com/gin-gonic/gin/internal/json/json.go index c5f3efc88..c7ee83eb3 100644 --- a/vendor/github.com/gin-gonic/gin/internal/json/json.go +++ b/vendor/github.com/gin-gonic/gin/internal/json/json.go @@ -3,9 +3,6 @@ // license that can be found in the LICENSE file. //go:build !jsoniter && !go_json && !(sonic && avx && (linux || windows || darwin) && amd64) -// +build !jsoniter -// +build !go_json -// +build !sonic !avx !linux,!windows,!darwin !amd64 package json diff --git a/vendor/github.com/gin-gonic/gin/internal/json/jsoniter.go b/vendor/github.com/gin-gonic/gin/internal/json/jsoniter.go index 853b1a901..45ed16ba9 100644 --- a/vendor/github.com/gin-gonic/gin/internal/json/jsoniter.go +++ b/vendor/github.com/gin-gonic/gin/internal/json/jsoniter.go @@ -3,7 +3,6 @@ // license that can be found in the LICENSE file. //go:build jsoniter -// +build jsoniter package json diff --git a/vendor/github.com/gin-gonic/gin/internal/json/sonic.go b/vendor/github.com/gin-gonic/gin/internal/json/sonic.go index 5a9ca4b2d..529e16d07 100644 --- a/vendor/github.com/gin-gonic/gin/internal/json/sonic.go +++ b/vendor/github.com/gin-gonic/gin/internal/json/sonic.go @@ -3,10 +3,6 @@ // license that can be found in the LICENSE file. //go:build sonic && avx && (linux || windows || darwin) && amd64 -// +build sonic -// +build avx -// +build linux windows darwin -// +build amd64 package json diff --git a/vendor/github.com/gin-gonic/gin/recovery.go b/vendor/github.com/gin-gonic/gin/recovery.go index 2955c03a0..515f9d2ad 100644 --- a/vendor/github.com/gin-gonic/gin/recovery.go +++ b/vendor/github.com/gin-gonic/gin/recovery.go @@ -103,7 +103,7 @@ func CustomRecoveryWithWriter(out io.Writer, handle RecoveryFunc) HandlerFunc { } } -func defaultHandleRecovery(c *Context, err any) { +func defaultHandleRecovery(c *Context, _ any) { c.AbortWithStatus(http.StatusInternalServerError) } @@ -164,7 +164,7 @@ func function(pc uintptr) []byte { if period := bytes.Index(name, dot); period >= 0 { name = name[period+1:] } - name = bytes.Replace(name, centerDot, dot, -1) + name = bytes.ReplaceAll(name, centerDot, dot) return name } diff --git a/vendor/github.com/gin-gonic/gin/render/any.go b/vendor/github.com/gin-gonic/gin/render/any.go deleted file mode 100644 index b19ad45d9..000000000 --- a/vendor/github.com/gin-gonic/gin/render/any.go +++ /dev/null @@ -1,10 +0,0 @@ -// Copyright 2021 Gin Core Team. All rights reserved. -// Use of this source code is governed by a MIT style -// license that can be found in the LICENSE file. - -//go:build !go1.18 -// +build !go1.18 - -package render - -type any = interface{} diff --git a/vendor/github.com/gin-gonic/gin/render/msgpack.go b/vendor/github.com/gin-gonic/gin/render/msgpack.go index e0f30f7a9..d1d8e84b0 100644 --- a/vendor/github.com/gin-gonic/gin/render/msgpack.go +++ b/vendor/github.com/gin-gonic/gin/render/msgpack.go @@ -3,7 +3,6 @@ // license that can be found in the LICENSE file. //go:build !nomsgpack -// +build !nomsgpack package render diff --git a/vendor/github.com/gin-gonic/gin/utils.go b/vendor/github.com/gin-gonic/gin/utils.go index 4021a2ab4..47106a7ae 100644 --- a/vendor/github.com/gin-gonic/gin/utils.go +++ b/vendor/github.com/gin-gonic/gin/utils.go @@ -50,7 +50,7 @@ func WrapH(h http.Handler) HandlerFunc { } } -// H is a shortcut for map[string]interface{} +// H is a shortcut for map[string]any type H map[string]any // MarshalXML allows type H to be used with xml.Marshal. diff --git a/vendor/github.com/gin-gonic/gin/version.go b/vendor/github.com/gin-gonic/gin/version.go index 390da4f3e..85462e555 100644 --- a/vendor/github.com/gin-gonic/gin/version.go +++ b/vendor/github.com/gin-gonic/gin/version.go @@ -5,4 +5,4 @@ package gin // Version is the current gin framework's version. -const Version = "v1.9.0" +const Version = "v1.9.1" diff --git a/vendor/github.com/goccy/go-json/CHANGELOG.md b/vendor/github.com/goccy/go-json/CHANGELOG.md index d63009fd7..d09bb89c3 100644 --- a/vendor/github.com/goccy/go-json/CHANGELOG.md +++ b/vendor/github.com/goccy/go-json/CHANGELOG.md @@ -1,3 +1,35 @@ +# v0.10.2 - 2023/03/20 + +### New features + +* Support DebugDOT option for debugging encoder ( #440 ) + +### Fix bugs + +* Fix combination of embedding structure and omitempty option ( #442 ) + +# v0.10.1 - 2023/03/13 + +### Fix bugs + +* Fix checkptr error for array decoder ( #415 ) +* Fix added buffer size check when decoding key ( #430 ) +* Fix handling of anonymous fields other than struct ( #431 ) +* Fix to not optimize when lower conversion can't handle byte-by-byte ( #432 ) +* Fix a problem that MarshalIndent does not work when UnorderedMap is specified ( #435 ) +* Fix mapDecoder.DecodeStream() for empty objects containing whitespace ( #425 ) +* Fix an issue that could not set the correct NextField for fields in the embedded structure ( #438 ) + +# v0.10.0 - 2022/11/29 + +### New features + +* Support JSON Path ( #250 ) + +### Fix bugs + +* Fix marshaler for map's key ( #409 ) + # v0.9.11 - 2022/08/18 ### Fix bugs diff --git a/vendor/github.com/goccy/go-json/internal/decoder/array.go b/vendor/github.com/goccy/go-json/internal/decoder/array.go index 8ef91cfa1..4b23ed43f 100644 --- a/vendor/github.com/goccy/go-json/internal/decoder/array.go +++ b/vendor/github.com/goccy/go-json/internal/decoder/array.go @@ -19,7 +19,9 @@ type arrayDecoder struct { } func newArrayDecoder(dec Decoder, elemType *runtime.Type, alen int, structName, fieldName string) *arrayDecoder { - zeroValue := *(*unsafe.Pointer)(unsafe_New(elemType)) + // workaround to avoid checkptr errors. cannot use `*(*unsafe.Pointer)(unsafe_New(elemType))` directly. + zeroValuePtr := unsafe_New(elemType) + zeroValue := **(**unsafe.Pointer)(unsafe.Pointer(&zeroValuePtr)) return &arrayDecoder{ valueDecoder: dec, elemType: elemType, diff --git a/vendor/github.com/goccy/go-json/internal/decoder/map.go b/vendor/github.com/goccy/go-json/internal/decoder/map.go index 7a6eea34f..07a9caea6 100644 --- a/vendor/github.com/goccy/go-json/internal/decoder/map.go +++ b/vendor/github.com/goccy/go-json/internal/decoder/map.go @@ -88,7 +88,7 @@ func (d *mapDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) erro mapValue = makemap(d.mapType, 0) } s.cursor++ - if s.equalChar('}') { + if s.skipWhiteSpace() == '}' { *(*unsafe.Pointer)(p) = mapValue s.cursor++ return nil diff --git a/vendor/github.com/goccy/go-json/internal/decoder/struct.go b/vendor/github.com/goccy/go-json/internal/decoder/struct.go index 6d3265489..313da153b 100644 --- a/vendor/github.com/goccy/go-json/internal/decoder/struct.go +++ b/vendor/github.com/goccy/go-json/internal/decoder/struct.go @@ -51,6 +51,14 @@ func init() { } } +func toASCIILower(s string) string { + b := []byte(s) + for i := range b { + b[i] = largeToSmallTable[b[i]] + } + return string(b) +} + func newStructDecoder(structName, fieldName string, fieldMap map[string]*structFieldSet) *structDecoder { return &structDecoder{ fieldMap: fieldMap, @@ -91,6 +99,10 @@ func (d *structDecoder) tryOptimize() { for k, v := range d.fieldMap { key := strings.ToLower(k) if key != k { + if key != toASCIILower(k) { + d.isTriedOptimize = true + return + } // already exists same key (e.g. Hello and HELLO has same lower case key if _, exists := conflicted[key]; exists { d.isTriedOptimize = true @@ -158,49 +170,53 @@ func (d *structDecoder) tryOptimize() { } // decode from '\uXXXX' -func decodeKeyCharByUnicodeRune(buf []byte, cursor int64) ([]byte, int64) { +func decodeKeyCharByUnicodeRune(buf []byte, cursor int64) ([]byte, int64, error) { const defaultOffset = 4 const surrogateOffset = 6 + if cursor+defaultOffset >= int64(len(buf)) { + return nil, 0, errors.ErrUnexpectedEndOfJSON("escaped string", cursor) + } + r := unicodeToRune(buf[cursor : cursor+defaultOffset]) if utf16.IsSurrogate(r) { cursor += defaultOffset if cursor+surrogateOffset >= int64(len(buf)) || buf[cursor] != '\\' || buf[cursor+1] != 'u' { - return []byte(string(unicode.ReplacementChar)), cursor + defaultOffset - 1 + return []byte(string(unicode.ReplacementChar)), cursor + defaultOffset - 1, nil } cursor += 2 r2 := unicodeToRune(buf[cursor : cursor+defaultOffset]) if r := utf16.DecodeRune(r, r2); r != unicode.ReplacementChar { - return []byte(string(r)), cursor + defaultOffset - 1 + return []byte(string(r)), cursor + defaultOffset - 1, nil } } - return []byte(string(r)), cursor + defaultOffset - 1 + return []byte(string(r)), cursor + defaultOffset - 1, nil } -func decodeKeyCharByEscapedChar(buf []byte, cursor int64) ([]byte, int64) { +func decodeKeyCharByEscapedChar(buf []byte, cursor int64) ([]byte, int64, error) { c := buf[cursor] cursor++ switch c { case '"': - return []byte{'"'}, cursor + return []byte{'"'}, cursor, nil case '\\': - return []byte{'\\'}, cursor + return []byte{'\\'}, cursor, nil case '/': - return []byte{'/'}, cursor + return []byte{'/'}, cursor, nil case 'b': - return []byte{'\b'}, cursor + return []byte{'\b'}, cursor, nil case 'f': - return []byte{'\f'}, cursor + return []byte{'\f'}, cursor, nil case 'n': - return []byte{'\n'}, cursor + return []byte{'\n'}, cursor, nil case 'r': - return []byte{'\r'}, cursor + return []byte{'\r'}, cursor, nil case 't': - return []byte{'\t'}, cursor + return []byte{'\t'}, cursor, nil case 'u': return decodeKeyCharByUnicodeRune(buf, cursor) } - return nil, cursor + return nil, cursor, nil } func decodeKeyByBitmapUint8(d *structDecoder, buf []byte, cursor int64) (int64, *structFieldSet, error) { @@ -242,7 +258,10 @@ func decodeKeyByBitmapUint8(d *structDecoder, buf []byte, cursor int64) (int64, return 0, nil, errors.ErrUnexpectedEndOfJSON("string", cursor) case '\\': cursor++ - chars, nextCursor := decodeKeyCharByEscapedChar(buf, cursor) + chars, nextCursor, err := decodeKeyCharByEscapedChar(buf, cursor) + if err != nil { + return 0, nil, err + } for _, c := range chars { curBit &= bitmap[keyIdx][largeToSmallTable[c]] if curBit == 0 { @@ -305,7 +324,10 @@ func decodeKeyByBitmapUint16(d *structDecoder, buf []byte, cursor int64) (int64, return 0, nil, errors.ErrUnexpectedEndOfJSON("string", cursor) case '\\': cursor++ - chars, nextCursor := decodeKeyCharByEscapedChar(buf, cursor) + chars, nextCursor, err := decodeKeyCharByEscapedChar(buf, cursor) + if err != nil { + return 0, nil, err + } for _, c := range chars { curBit &= bitmap[keyIdx][largeToSmallTable[c]] if curBit == 0 { diff --git a/vendor/github.com/goccy/go-json/internal/encoder/code.go b/vendor/github.com/goccy/go-json/internal/encoder/code.go index 8d62a9cd5..5b08faefc 100644 --- a/vendor/github.com/goccy/go-json/internal/encoder/code.go +++ b/vendor/github.com/goccy/go-json/internal/encoder/code.go @@ -397,7 +397,10 @@ func (c *StructCode) lastFieldCode(field *StructFieldCode, firstField *Opcode) * func (c *StructCode) lastAnonymousFieldCode(firstField *Opcode) *Opcode { // firstField is special StructHead operation for anonymous structure. // So, StructHead's next operation is truly struct head operation. - lastField := firstField.Next + for firstField.Op == OpStructHead || firstField.Op == OpStructField { + firstField = firstField.Next + } + lastField := firstField for lastField.NextField != nil { lastField = lastField.NextField } @@ -437,11 +440,6 @@ func (c *StructCode) ToOpcode(ctx *compileContext) Opcodes { } if isEndField { endField := fieldCodes.Last() - if isEmbeddedStruct(field) { - firstField.End = endField - lastField := c.lastAnonymousFieldCode(firstField) - lastField.NextField = endField - } if len(codes) > 0 { codes.First().End = endField } else { @@ -698,7 +696,15 @@ func (c *StructFieldCode) addStructEndCode(ctx *compileContext, codes Opcodes) O Indent: ctx.indent, } codes.Last().Next = end - codes.First().NextField = end + code := codes.First() + for code.Op == OpStructField || code.Op == OpStructHead { + code = code.Next + } + for code.NextField != nil { + code = code.NextField + } + code.NextField = end + codes = codes.Add(end) ctx.incOpcodeIndex() return codes diff --git a/vendor/github.com/goccy/go-json/internal/encoder/compiler.go b/vendor/github.com/goccy/go-json/internal/encoder/compiler.go index 3b3ff3fde..3ae39ba8c 100644 --- a/vendor/github.com/goccy/go-json/internal/encoder/compiler.go +++ b/vendor/github.com/goccy/go-json/internal/encoder/compiler.go @@ -617,6 +617,13 @@ func (c *Compiler) structCode(typ *runtime.Type, isPtr bool) (*StructCode, error return code, nil } +func toElemType(t *runtime.Type) *runtime.Type { + for t.Kind() == reflect.Ptr { + t = t.Elem() + } + return t +} + func (c *Compiler) structFieldCode(structCode *StructCode, tag *runtime.StructTag, isPtr, isOnlyOneFirstField bool) (*StructFieldCode, error) { field := tag.Field fieldType := runtime.Type2RType(field.Type) @@ -626,7 +633,7 @@ func (c *Compiler) structFieldCode(structCode *StructCode, tag *runtime.StructTa key: tag.Key, tag: tag, offset: field.Offset, - isAnonymous: field.Anonymous && !tag.IsTaggedKey, + isAnonymous: field.Anonymous && !tag.IsTaggedKey && toElemType(fieldType).Kind() == reflect.Struct, isTaggedKey: tag.IsTaggedKey, isNilableType: c.isNilableType(fieldType), isNilCheck: true, diff --git a/vendor/github.com/goccy/go-json/internal/encoder/opcode.go b/vendor/github.com/goccy/go-json/internal/encoder/opcode.go index 05fc3ce04..df22f5542 100644 --- a/vendor/github.com/goccy/go-json/internal/encoder/opcode.go +++ b/vendor/github.com/goccy/go-json/internal/encoder/opcode.go @@ -1,7 +1,9 @@ package encoder import ( + "bytes" "fmt" + "sort" "strings" "unsafe" @@ -555,6 +557,87 @@ func (c *Opcode) Dump() string { return strings.Join(codes, "\n") } +func (c *Opcode) DumpDOT() string { + type edge struct { + from, to *Opcode + label string + weight int + } + var edges []edge + + b := &bytes.Buffer{} + fmt.Fprintf(b, "digraph \"%p\" {\n", c.Type) + fmt.Fprintln(b, "mclimit=1.5;\nrankdir=TD;\nordering=out;\nnode[shape=box];") + for code := c; !code.IsEnd(); { + label := code.Op.String() + fmt.Fprintf(b, "\"%p\" [label=%q];\n", code, label) + if p := code.Next; p != nil { + edges = append(edges, edge{ + from: code, + to: p, + label: "Next", + weight: 10, + }) + } + if p := code.NextField; p != nil { + edges = append(edges, edge{ + from: code, + to: p, + label: "NextField", + weight: 2, + }) + } + if p := code.End; p != nil { + edges = append(edges, edge{ + from: code, + to: p, + label: "End", + weight: 1, + }) + } + if p := code.Jmp; p != nil { + edges = append(edges, edge{ + from: code, + to: p.Code, + label: "Jmp", + weight: 1, + }) + } + + switch code.Op.CodeType() { + case CodeSliceHead: + code = code.Next + case CodeMapHead: + code = code.Next + case CodeArrayElem, CodeSliceElem: + code = code.End + case CodeMapKey: + code = code.End + case CodeMapValue: + code = code.Next + case CodeMapEnd: + code = code.Next + case CodeStructField: + code = code.Next + case CodeStructEnd: + code = code.Next + default: + code = code.Next + } + if code.IsEnd() { + fmt.Fprintf(b, "\"%p\" [label=%q];\n", code, code.Op.String()) + } + } + sort.Slice(edges, func(i, j int) bool { + return edges[i].to.DisplayIdx < edges[j].to.DisplayIdx + }) + for _, e := range edges { + fmt.Fprintf(b, "\"%p\" -> \"%p\" [label=%q][weight=%d];\n", e.from, e.to, e.label, e.weight) + } + fmt.Fprint(b, "}") + return b.String() +} + func newSliceHeaderCode(ctx *compileContext, typ *runtime.Type) *Opcode { idx := opcodeOffset(ctx.ptrIndex) ctx.incPtrIndex() diff --git a/vendor/github.com/goccy/go-json/internal/encoder/option.go b/vendor/github.com/goccy/go-json/internal/encoder/option.go index 82d5ce3e7..12c58e46c 100644 --- a/vendor/github.com/goccy/go-json/internal/encoder/option.go +++ b/vendor/github.com/goccy/go-json/internal/encoder/option.go @@ -23,6 +23,7 @@ type Option struct { ColorScheme *ColorScheme Context context.Context DebugOut io.Writer + DebugDOTOut io.WriteCloser } type EncodeFormat struct { diff --git a/vendor/github.com/goccy/go-json/internal/encoder/vm/debug_vm.go b/vendor/github.com/goccy/go-json/internal/encoder/vm/debug_vm.go index fbbc0de44..82b6dd47f 100644 --- a/vendor/github.com/goccy/go-json/internal/encoder/vm/debug_vm.go +++ b/vendor/github.com/goccy/go-json/internal/encoder/vm/debug_vm.go @@ -2,6 +2,7 @@ package vm import ( "fmt" + "io" "github.com/goccy/go-json/internal/encoder" ) @@ -14,6 +15,11 @@ func DebugRun(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet) } else { code = codeSet.NoescapeKeyCode } + if wc := ctx.Option.DebugDOTOut; wc != nil { + _, _ = io.WriteString(wc, code.DumpDOT()) + wc.Close() + ctx.Option.DebugDOTOut = nil + } if err := recover(); err != nil { w := ctx.Option.DebugOut diff --git a/vendor/github.com/goccy/go-json/internal/encoder/vm_color_indent/util.go b/vendor/github.com/goccy/go-json/internal/encoder/vm_color_indent/util.go index 60e4a8ed5..2395abec9 100644 --- a/vendor/github.com/goccy/go-json/internal/encoder/vm_color_indent/util.go +++ b/vendor/github.com/goccy/go-json/internal/encoder/vm_color_indent/util.go @@ -189,7 +189,7 @@ func appendNullComma(ctx *encoder.RuntimeContext, b []byte) []byte { } func appendColon(_ *encoder.RuntimeContext, b []byte) []byte { - return append(b, ':', ' ') + return append(b[:len(b)-2], ':', ' ') } func appendMapKeyValue(ctx *encoder.RuntimeContext, code *encoder.Opcode, b, key, value []byte) []byte { @@ -229,8 +229,9 @@ func appendEmptyObject(_ *encoder.RuntimeContext, b []byte) []byte { func appendObjectEnd(ctx *encoder.RuntimeContext, code *encoder.Opcode, b []byte) []byte { last := len(b) - 1 - b[last] = '\n' - b = appendIndent(ctx, b, code.Indent-1) + // replace comma to newline + b[last-1] = '\n' + b = appendIndent(ctx, b[:last], code.Indent) return append(b, '}', ',', '\n') } diff --git a/vendor/github.com/goccy/go-json/internal/encoder/vm_indent/util.go b/vendor/github.com/goccy/go-json/internal/encoder/vm_indent/util.go index fca8f1855..6cb745e39 100644 --- a/vendor/github.com/goccy/go-json/internal/encoder/vm_indent/util.go +++ b/vendor/github.com/goccy/go-json/internal/encoder/vm_indent/util.go @@ -133,7 +133,7 @@ func appendNullComma(_ *encoder.RuntimeContext, b []byte) []byte { } func appendColon(_ *encoder.RuntimeContext, b []byte) []byte { - return append(b, ':', ' ') + return append(b[:len(b)-2], ':', ' ') } func appendMapKeyValue(ctx *encoder.RuntimeContext, code *encoder.Opcode, b, key, value []byte) []byte { @@ -173,8 +173,9 @@ func appendEmptyObject(_ *encoder.RuntimeContext, b []byte) []byte { func appendObjectEnd(ctx *encoder.RuntimeContext, code *encoder.Opcode, b []byte) []byte { last := len(b) - 1 - b[last] = '\n' - b = appendIndent(ctx, b, code.Indent-1) + // replace comma to newline + b[last-1] = '\n' + b = appendIndent(ctx, b[:last], code.Indent) return append(b, '}', ',', '\n') } diff --git a/vendor/github.com/goccy/go-json/option.go b/vendor/github.com/goccy/go-json/option.go index af400a452..378031a08 100644 --- a/vendor/github.com/goccy/go-json/option.go +++ b/vendor/github.com/goccy/go-json/option.go @@ -48,6 +48,13 @@ func DebugWith(w io.Writer) EncodeOptionFunc { } } +// DebugDOT sets the destination to write opcodes graph. +func DebugDOT(w io.WriteCloser) EncodeOptionFunc { + return func(opt *EncodeOption) { + opt.DebugDOTOut = w + } +} + // Colorize add an identifier for coloring to the string of the encoded result. func Colorize(scheme *ColorScheme) EncodeOptionFunc { return func(opt *EncodeOption) { diff --git a/vendor/github.com/pelletier/go-toml/v2/README.md b/vendor/github.com/pelletier/go-toml/v2/README.md index 9f8439cc7..d53f43971 100644 --- a/vendor/github.com/pelletier/go-toml/v2/README.md +++ b/vendor/github.com/pelletier/go-toml/v2/README.md @@ -553,7 +553,7 @@ complete solutions exist out there. ## Versioning -Go-toml follows [Semantic Versioning](http://semver.org/). The supported version +Go-toml follows [Semantic Versioning](https://semver.org). The supported version of [TOML](https://github.com/toml-lang/toml) is indicated at the beginning of this document. The last two major versions of Go are supported (see [Go Release Policy](https://golang.org/doc/devel/release.html#policy)). diff --git a/vendor/github.com/pelletier/go-toml/v2/ci.sh b/vendor/github.com/pelletier/go-toml/v2/ci.sh index d916c5f23..05c76f297 100644 --- a/vendor/github.com/pelletier/go-toml/v2/ci.sh +++ b/vendor/github.com/pelletier/go-toml/v2/ci.sh @@ -77,7 +77,7 @@ cover() { pushd "$dir" go test -covermode=atomic -coverpkg=./... -coverprofile=coverage.out.tmp ./... - cat coverage.out.tmp | grep -v testsuite | grep -v tomltestgen | grep -v gotoml-test-decoder > coverage.out + cat coverage.out.tmp | grep -v fuzz | grep -v testsuite | grep -v tomltestgen | grep -v gotoml-test-decoder > coverage.out go tool cover -func=coverage.out popd diff --git a/vendor/github.com/pelletier/go-toml/v2/marshaler.go b/vendor/github.com/pelletier/go-toml/v2/marshaler.go index 07aceb902..6ab1d8238 100644 --- a/vendor/github.com/pelletier/go-toml/v2/marshaler.go +++ b/vendor/github.com/pelletier/go-toml/v2/marshaler.go @@ -357,9 +357,9 @@ func (enc *Encoder) encodeKv(b []byte, ctx encoderCtx, options valueOptions, v r if !ctx.inline { b = enc.encodeComment(ctx.indent, options.comment, b) + b = enc.indent(ctx.indent, b) } - b = enc.indent(ctx.indent, b) b = enc.encodeKey(b, ctx.key) b = append(b, " = "...) @@ -577,11 +577,23 @@ func (enc *Encoder) encodeKey(b []byte, k string) []byte { } } -func (enc *Encoder) encodeMap(b []byte, ctx encoderCtx, v reflect.Value) ([]byte, error) { - if v.Type().Key().Kind() != reflect.String { - return nil, fmt.Errorf("toml: type %s is not supported as a map key", v.Type().Key().Kind()) +func (enc *Encoder) keyToString(k reflect.Value) (string, error) { + keyType := k.Type() + switch { + case keyType.Kind() == reflect.String: + return k.String(), nil + + case keyType.Implements(textMarshalerType): + keyB, err := k.Interface().(encoding.TextMarshaler).MarshalText() + if err != nil { + return "", fmt.Errorf("toml: error marshalling key %v from text: %w", k, err) + } + return string(keyB), nil } + return "", fmt.Errorf("toml: type %s is not supported as a map key", keyType.Kind()) +} +func (enc *Encoder) encodeMap(b []byte, ctx encoderCtx, v reflect.Value) ([]byte, error) { var ( t table emptyValueOptions valueOptions @@ -589,13 +601,17 @@ func (enc *Encoder) encodeMap(b []byte, ctx encoderCtx, v reflect.Value) ([]byte iter := v.MapRange() for iter.Next() { - k := iter.Key().String() v := iter.Value() if isNil(v) { continue } + k, err := enc.keyToString(iter.Key()) + if err != nil { + return nil, err + } + if willConvertToTableOrArrayTable(ctx, v) { t.pushTable(k, v, emptyValueOptions) } else { diff --git a/vendor/github.com/pelletier/go-toml/v2/unmarshaler.go b/vendor/github.com/pelletier/go-toml/v2/unmarshaler.go index 70f6ec572..393503431 100644 --- a/vendor/github.com/pelletier/go-toml/v2/unmarshaler.go +++ b/vendor/github.com/pelletier/go-toml/v2/unmarshaler.go @@ -60,7 +60,7 @@ func (d *Decoder) DisallowUnknownFields() *Decoder { // are ignored. See Decoder.DisallowUnknownFields() to change this behavior. // // When a TOML local date, time, or date-time is decoded into a time.Time, its -// value is represented in time.Local timezone. Otherwise the approriate Local* +// value is represented in time.Local timezone. Otherwise the appropriate Local* // structure is used. For time values, precision up to the nanosecond is // supported by truncating extra digits. // @@ -417,7 +417,10 @@ func (d *decoder) handleKeyPart(key unstable.Iterator, v reflect.Value, nextFn h vt := v.Type() // Create the key for the map element. Convert to key type. - mk := reflect.ValueOf(string(key.Node().Data)).Convert(vt.Key()) + mk, err := d.keyFromData(vt.Key(), key.Node().Data) + if err != nil { + return reflect.Value{}, err + } // If the map does not exist, create it. if v.IsNil() { @@ -746,7 +749,7 @@ func (d *decoder) unmarshalInlineTable(itable *unstable.Node, v reflect.Value) e } return d.unmarshalInlineTable(itable, elem) default: - return unstable.NewParserError(itable.Data, "cannot store inline table in Go type %s", v.Kind()) + return unstable.NewParserError(d.p.Raw(itable.Raw), "cannot store inline table in Go type %s", v.Kind()) } it := itable.Children() @@ -887,6 +890,11 @@ func init() { } func (d *decoder) unmarshalInteger(value *unstable.Node, v reflect.Value) error { + kind := v.Kind() + if kind == reflect.Float32 || kind == reflect.Float64 { + return d.unmarshalFloat(value, v) + } + i, err := parseInteger(value.Data) if err != nil { return err @@ -894,7 +902,7 @@ func (d *decoder) unmarshalInteger(value *unstable.Node, v reflect.Value) error var r reflect.Value - switch v.Kind() { + switch kind { case reflect.Int64: v.SetInt(i) return nil @@ -1004,6 +1012,31 @@ func (d *decoder) handleKeyValueInner(key unstable.Iterator, value *unstable.Nod return reflect.Value{}, d.handleValue(value, v) } +func (d *decoder) keyFromData(keyType reflect.Type, data []byte) (reflect.Value, error) { + switch { + case stringType.AssignableTo(keyType): + return reflect.ValueOf(string(data)), nil + + case stringType.ConvertibleTo(keyType): + return reflect.ValueOf(string(data)).Convert(keyType), nil + + case keyType.Implements(textUnmarshalerType): + mk := reflect.New(keyType.Elem()) + if err := mk.Interface().(encoding.TextUnmarshaler).UnmarshalText(data); err != nil { + return reflect.Value{}, fmt.Errorf("toml: error unmarshalling key type %s from text: %w", stringType, err) + } + return mk, nil + + case reflect.PtrTo(keyType).Implements(textUnmarshalerType): + mk := reflect.New(keyType) + if err := mk.Interface().(encoding.TextUnmarshaler).UnmarshalText(data); err != nil { + return reflect.Value{}, fmt.Errorf("toml: error unmarshalling key type %s from text: %w", stringType, err) + } + return mk.Elem(), nil + } + return reflect.Value{}, fmt.Errorf("toml: cannot convert map key of type %s to expected type %s", stringType, keyType) +} + func (d *decoder) handleKeyValuePart(key unstable.Iterator, value *unstable.Node, v reflect.Value) (reflect.Value, error) { // contains the replacement for v var rv reflect.Value @@ -1014,16 +1047,9 @@ func (d *decoder) handleKeyValuePart(key unstable.Iterator, value *unstable.Node case reflect.Map: vt := v.Type() - mk := reflect.ValueOf(string(key.Node().Data)) - mkt := stringType - - keyType := vt.Key() - if !mkt.AssignableTo(keyType) { - if !mkt.ConvertibleTo(keyType) { - return reflect.Value{}, fmt.Errorf("toml: cannot convert map key of type %s to expected type %s", mkt, keyType) - } - - mk = mk.Convert(keyType) + mk, err := d.keyFromData(vt.Key(), key.Node().Data) + if err != nil { + return reflect.Value{}, err } // If the map does not exist, create it. @@ -1034,15 +1060,9 @@ func (d *decoder) handleKeyValuePart(key unstable.Iterator, value *unstable.Node mv := v.MapIndex(mk) set := false - if !mv.IsValid() { + if !mv.IsValid() || key.IsLast() { set = true mv = reflect.New(v.Type().Elem()).Elem() - } else { - if key.IsLast() { - var x interface{} - mv = reflect.ValueOf(&x).Elem() - set = true - } } nv, err := d.handleKeyValueInner(key, value, mv) @@ -1072,6 +1092,19 @@ func (d *decoder) handleKeyValuePart(key unstable.Iterator, value *unstable.Node d.errorContext.Field = path f := fieldByIndex(v, path) + + if !f.CanSet() { + // If the field is not settable, need to take a slower path and make a copy of + // the struct itself to a new location. + nvp := reflect.New(v.Type()) + nvp.Elem().Set(v) + v = nvp.Elem() + _, err := d.handleKeyValuePart(key, value, v) + if err != nil { + return reflect.Value{}, err + } + return nvp.Elem(), nil + } x, err := d.handleKeyValueInner(key, value, f) if err != nil { return reflect.Value{}, err diff --git a/vendor/github.com/pelletier/go-toml/v2/unstable/ast.go b/vendor/github.com/pelletier/go-toml/v2/unstable/ast.go index b60d9bfd6..f526bf2c0 100644 --- a/vendor/github.com/pelletier/go-toml/v2/unstable/ast.go +++ b/vendor/github.com/pelletier/go-toml/v2/unstable/ast.go @@ -58,7 +58,7 @@ func (c *Iterator) Node() *Node { // - Table and ArrayTable's children represent a dotted key (same as // KeyValue, but without the first node being the value). // -// When relevant, Raw describes the range of bytes this node is refering to in +// When relevant, Raw describes the range of bytes this node is referring to in // the input document. Use Parser.Raw() to retrieve the actual bytes. type Node struct { Kind Kind diff --git a/vendor/github.com/pelletier/go-toml/v2/unstable/parser.go b/vendor/github.com/pelletier/go-toml/v2/unstable/parser.go index 52db88e7a..a8eb05294 100644 --- a/vendor/github.com/pelletier/go-toml/v2/unstable/parser.go +++ b/vendor/github.com/pelletier/go-toml/v2/unstable/parser.go @@ -49,8 +49,6 @@ func NewParserError(highlight []byte, format string, args ...interface{}) error // For performance reasons, go-toml doesn't make a copy of the input bytes to // the parser. Make sure to copy all the bytes you need to outlive the slice // given to the parser. -// -// The parser doesn't provide nodes for comments yet, nor for whitespace. type Parser struct { data []byte builder builder @@ -58,6 +56,8 @@ type Parser struct { left []byte err error first bool + + KeepComments bool } // Data returns the slice provided to the last call to Reset. @@ -132,16 +132,54 @@ func (p *Parser) NextExpression() bool { } // Expression returns a pointer to the node representing the last successfully -// parsed expresion. +// parsed expression. func (p *Parser) Expression() *Node { return p.builder.NodeAt(p.ref) } -// Error returns any error that has occured during parsing. +// Error returns any error that has occurred during parsing. func (p *Parser) Error() error { return p.err } +// Position describes a position in the input. +type Position struct { + // Number of bytes from the beginning of the input. + Offset int + // Line number, starting at 1. + Line int + // Column number, starting at 1. + Column int +} + +// Shape describes the position of a range in the input. +type Shape struct { + Start Position + End Position +} + +func (p *Parser) position(b []byte) Position { + offset := danger.SubsliceOffset(p.data, b) + + lead := p.data[:offset] + + return Position{ + Offset: offset, + Line: bytes.Count(lead, []byte{'\n'}) + 1, + Column: len(lead) - bytes.LastIndex(lead, []byte{'\n'}), + } +} + +// Shape returns the shape of the given range in the input. Will +// panic if the range is not a subslice of the input. +func (p *Parser) Shape(r Range) Shape { + raw := p.Raw(r) + return Shape{ + Start: p.position(raw), + End: p.position(raw[r.Length:]), + } +} + func (p *Parser) parseNewline(b []byte) ([]byte, error) { if b[0] == '\n' { return b[1:], nil @@ -155,6 +193,19 @@ func (p *Parser) parseNewline(b []byte) ([]byte, error) { return nil, NewParserError(b[0:1], "expected newline but got %#U", b[0]) } +func (p *Parser) parseComment(b []byte) (reference, []byte, error) { + ref := invalidReference + data, rest, err := scanComment(b) + if p.KeepComments && err == nil { + ref = p.builder.Push(Node{ + Kind: Comment, + Raw: p.Range(data), + Data: data, + }) + } + return ref, rest, err +} + func (p *Parser) parseExpression(b []byte) (reference, []byte, error) { // expression = ws [ comment ] // expression =/ ws keyval ws [ comment ] @@ -168,7 +219,7 @@ func (p *Parser) parseExpression(b []byte) (reference, []byte, error) { } if b[0] == '#' { - _, rest, err := scanComment(b) + ref, rest, err := p.parseComment(b) return ref, rest, err } @@ -190,7 +241,10 @@ func (p *Parser) parseExpression(b []byte) (reference, []byte, error) { b = p.parseWhitespace(b) if len(b) > 0 && b[0] == '#' { - _, rest, err := scanComment(b) + cref, rest, err := p.parseComment(b) + if cref != invalidReference { + p.builder.Chain(ref, cref) + } return ref, rest, err } @@ -402,6 +456,7 @@ func (p *Parser) parseInlineTable(b []byte) (reference, []byte, error) { // inline-table-keyvals = keyval [ inline-table-sep inline-table-keyvals ] parent := p.builder.Push(Node{ Kind: InlineTable, + Raw: p.Range(b[:1]), }) first := true @@ -470,17 +525,33 @@ func (p *Parser) parseValArray(b []byte) (reference, []byte, error) { Kind: Array, }) + // First indicates whether the parser is looking for the first element + // (non-comment) of the array. first := true - var lastChild reference + lastChild := invalidReference + + addChild := func(valueRef reference) { + if lastChild == invalidReference { + p.builder.AttachChild(parent, valueRef) + } else { + p.builder.Chain(lastChild, valueRef) + } + lastChild = valueRef + } var err error for len(b) > 0 { - b, err = p.parseOptionalWhitespaceCommentNewline(b) + cref := invalidReference + cref, b, err = p.parseOptionalWhitespaceCommentNewline(b) if err != nil { return parent, nil, err } + if cref != invalidReference { + addChild(cref) + } + if len(b) == 0 { return parent, nil, NewParserError(arrayStart[:1], "array is incomplete") } @@ -495,10 +566,13 @@ func (p *Parser) parseValArray(b []byte) (reference, []byte, error) { } b = b[1:] - b, err = p.parseOptionalWhitespaceCommentNewline(b) + cref, b, err = p.parseOptionalWhitespaceCommentNewline(b) if err != nil { return parent, nil, err } + if cref != invalidReference { + addChild(cref) + } } else if !first { return parent, nil, NewParserError(b[0:1], "array elements must be separated by commas") } @@ -514,17 +588,16 @@ func (p *Parser) parseValArray(b []byte) (reference, []byte, error) { return parent, nil, err } - if first { - p.builder.AttachChild(parent, valueRef) - } else { - p.builder.Chain(lastChild, valueRef) - } - lastChild = valueRef + addChild(valueRef) - b, err = p.parseOptionalWhitespaceCommentNewline(b) + cref, b, err = p.parseOptionalWhitespaceCommentNewline(b) if err != nil { return parent, nil, err } + if cref != invalidReference { + addChild(cref) + } + first = false } @@ -533,15 +606,34 @@ func (p *Parser) parseValArray(b []byte) (reference, []byte, error) { return parent, rest, err } -func (p *Parser) parseOptionalWhitespaceCommentNewline(b []byte) ([]byte, error) { +func (p *Parser) parseOptionalWhitespaceCommentNewline(b []byte) (reference, []byte, error) { + rootCommentRef := invalidReference + latestCommentRef := invalidReference + + addComment := func(ref reference) { + if rootCommentRef == invalidReference { + rootCommentRef = ref + } else if latestCommentRef == invalidReference { + p.builder.AttachChild(rootCommentRef, ref) + latestCommentRef = ref + } else { + p.builder.Chain(latestCommentRef, ref) + latestCommentRef = ref + } + } + for len(b) > 0 { var err error b = p.parseWhitespace(b) if len(b) > 0 && b[0] == '#' { - _, b, err = scanComment(b) + var ref reference + ref, b, err = p.parseComment(b) if err != nil { - return nil, err + return invalidReference, nil, err + } + if ref != invalidReference { + addComment(ref) } } @@ -552,14 +644,14 @@ func (p *Parser) parseOptionalWhitespaceCommentNewline(b []byte) ([]byte, error) if b[0] == '\n' || b[0] == '\r' { b, err = p.parseNewline(b) if err != nil { - return nil, err + return invalidReference, nil, err } } else { break } } - return b, nil + return rootCommentRef, b, nil } func (p *Parser) parseMultilineLiteralString(b []byte) ([]byte, []byte, []byte, error) { diff --git a/vendor/github.com/pelletier/go-toml/v2/unstable/scanner.go b/vendor/github.com/pelletier/go-toml/v2/unstable/scanner.go index af22ebbe9..0512181d2 100644 --- a/vendor/github.com/pelletier/go-toml/v2/unstable/scanner.go +++ b/vendor/github.com/pelletier/go-toml/v2/unstable/scanner.go @@ -151,7 +151,6 @@ func scanWhitespace(b []byte) ([]byte, []byte) { return b, b[len(b):] } -//nolint:unparam func scanComment(b []byte) ([]byte, []byte, error) { // comment-start-symbol = %x23 ; # // non-ascii = %x80-D7FF / %xE000-10FFFF diff --git a/vendor/github.com/ugorji/go/codec/README.md b/vendor/github.com/ugorji/go/codec/README.md index e4c45bc83..b8c1829bb 100644 --- a/vendor/github.com/ugorji/go/codec/README.md +++ b/vendor/github.com/ugorji/go/codec/README.md @@ -247,7 +247,7 @@ caveats. See Encode documentation. ```go const CborStreamBytes byte = 0x5f ... -const GenVersion = 26 +const GenVersion = 28 var SelfExt = &extFailWrapper{} var GoRpc goRpc var MsgpackSpecRpc msgpackSpecRpc diff --git a/vendor/github.com/ugorji/go/codec/decode.go b/vendor/github.com/ugorji/go/codec/decode.go index db87f2e71..d549188de 100644 --- a/vendor/github.com/ugorji/go/codec/decode.go +++ b/vendor/github.com/ugorji/go/codec/decode.go @@ -734,7 +734,7 @@ func (d *Decoder) kStruct(f *codecFnInfo, rv reflect.Value) { // iterate all the items in the stream // if mapped elem-wise to a field, handle it - // if more stream items than cap be mapped, error it + // if more stream items than can be mapped, error it for j := 0; d.containerNext(j, containerLen, hasLen); j++ { d.arrayElem() if j < len(tisfi) { diff --git a/vendor/github.com/ugorji/go/codec/encode.go b/vendor/github.com/ugorji/go/codec/encode.go index 53389b085..70361b5cc 100644 --- a/vendor/github.com/ugorji/go/codec/encode.go +++ b/vendor/github.com/ugorji/go/codec/encode.go @@ -893,6 +893,7 @@ func (e *Encoder) kMapCanonical(ti *typeInfo, rv, rvv reflect.Value, keyFn, valF v := &mksbv[i] l := len(mksv) + e.c = containerMapKey e.encodeValue(k, nil) e.atEndOfEncode() e.w().end() diff --git a/vendor/github.com/ugorji/go/codec/gen-helper.generated.go b/vendor/github.com/ugorji/go/codec/gen-helper.generated.go index 676203daf..9a145f140 100644 --- a/vendor/github.com/ugorji/go/codec/gen-helper.generated.go +++ b/vendor/github.com/ugorji/go/codec/gen-helper.generated.go @@ -13,7 +13,7 @@ import ( ) // GenVersion is the current version of codecgen. -const GenVersion = 26 +const GenVersion = 28 // This file is used to generate helper code for codecgen. // The values here i.e. genHelper(En|De)coder are not to be used directly by diff --git a/vendor/github.com/ugorji/go/codec/gen.go b/vendor/github.com/ugorji/go/codec/gen.go index d0cec1972..de7ee72f1 100644 --- a/vendor/github.com/ugorji/go/codec/gen.go +++ b/vendor/github.com/ugorji/go/codec/gen.go @@ -151,7 +151,9 @@ import ( // v24: 20210226 robust handling for Canonical|CheckCircularRef flags and MissingFielder implementations // v25: 20210406 pass base reflect.Type to side(En|De)code and (En|De)codeExt calls // v26: 20230201 genHelper changes for more inlining and consequent performance -const genVersion = 26 +// v27: 20230219 fix error decoding struct from array - due to misplaced counter increment +// v28: 20230224 fix decoding missing fields of struct from array, due to double counter increment +const genVersion = 28 const ( genCodecPkg = "codec1978" // MARKER: keep in sync with codecgen/gen.go @@ -2090,7 +2092,6 @@ func (x *genRunner) decStructArray(varname, lenvarname, breakString string, rtid x.linef("var %shl%s bool = %s >= 0", tpfx, i, lenvarname) // has length var newbuf, nilbuf genBuf for _, si := range tisfi { - x.linef("%sj%s++", tpfx, i) x.linef("%sb%s = !z.DecContainerNext(%sj%s, %s, %shl%s)", tpfx, i, tpfx, i, lenvarname, tpfx, i) x.linef("if %sb%s { z.DecReadArrayEnd(); %s }", tpfx, i, breakString) x.line("z.DecReadArrayElem()") @@ -2104,10 +2105,11 @@ func (x *genRunner) decStructArray(varname, lenvarname, breakString string, rtid if len(newbuf.buf) > 0 { x.line("}") } + x.linef("%sj%s++", tpfx, i) } // read remaining values and throw away. - x.linef("for %sj%s++; z.DecContainerNext(%sj%s, %s, %shl%s); %sj%s++ {", - tpfx, i, tpfx, i, lenvarname, tpfx, i, tpfx, i) + x.linef("for ; z.DecContainerNext(%sj%s, %s, %shl%s); %sj%s++ {", + tpfx, i, lenvarname, tpfx, i, tpfx, i) x.line("z.DecReadArrayElem()") x.linef(`z.DecStructFieldNotFound(%sj%s - 1, "")`, tpfx, i) x.line("}") diff --git a/vendor/golang.org/x/arch/AUTHORS b/vendor/golang.org/x/arch/AUTHORS deleted file mode 100644 index 2b00ddba0..000000000 --- a/vendor/golang.org/x/arch/AUTHORS +++ /dev/null @@ -1,3 +0,0 @@ -# This source code refers to The Go Authors for copyright purposes. -# The master list of authors is in the main Go distribution, -# visible at https://tip.golang.org/AUTHORS. diff --git a/vendor/golang.org/x/arch/CONTRIBUTORS b/vendor/golang.org/x/arch/CONTRIBUTORS deleted file mode 100644 index 1fbd3e976..000000000 --- a/vendor/golang.org/x/arch/CONTRIBUTORS +++ /dev/null @@ -1,3 +0,0 @@ -# This source code was written by the Go contributors. -# The master list of contributors is in the main Go distribution, -# visible at https://tip.golang.org/CONTRIBUTORS. diff --git a/vendor/golang.org/x/arch/x86/x86asm/decode.go b/vendor/golang.org/x/arch/x86/x86asm/decode.go index 8c984970b..059b73d3f 100644 --- a/vendor/golang.org/x/arch/x86/x86asm/decode.go +++ b/vendor/golang.org/x/arch/x86/x86asm/decode.go @@ -1550,7 +1550,7 @@ var addr16 = [8]Mem{ {Base: BX}, } -// baseReg returns the base register for a given register size in bits. +// baseRegForBits returns the base register for a given register size in bits. func baseRegForBits(bits int) Reg { switch bits { case 8: diff --git a/vendor/golang.org/x/arch/x86/x86asm/plan9x.go b/vendor/golang.org/x/arch/x86/x86asm/plan9x.go index 59d8f9775..de417946a 100644 --- a/vendor/golang.org/x/arch/x86/x86asm/plan9x.go +++ b/vendor/golang.org/x/arch/x86/x86asm/plan9x.go @@ -66,6 +66,10 @@ func GoSyntax(inst Inst, pc uint64, symname SymLookup) string { s := inst.DataSize if inst.MemBytes != 0 { s = inst.MemBytes * 8 + } else if inst.Args[1] == nil { // look for register-only 64-bit instruction, like PUSHQ AX + if r, ok := inst.Args[0].(Reg); ok && RAX <= r && r <= R15 { + s = 64 + } } switch s { case 8: diff --git a/vendor/golang.org/x/arch/x86/x86asm/tables.go b/vendor/golang.org/x/arch/x86/x86asm/tables.go index af3fb73c5..6f57c70bf 100644 --- a/vendor/golang.org/x/arch/x86/x86asm/tables.go +++ b/vendor/golang.org/x/arch/x86/x86asm/tables.go @@ -1,5 +1,4 @@ -// DO NOT EDIT -// generated by: x86map -fmt=decoder ../x86.csv +// Code generated by x86map -fmt=decoder x86.csv DO NOT EDIT. package x86asm diff --git a/vendor/modules.txt b/vendor/modules.txt index ae48d100f..38af992c4 100644 --- a/vendor/modules.txt +++ b/vendor/modules.txt @@ -86,7 +86,7 @@ github.com/aymerick/douceur/parser ## explicit; go 1.14 github.com/buckket/go-blurhash github.com/buckket/go-blurhash/base83 -# github.com/bytedance/sonic v1.8.0 +# github.com/bytedance/sonic v1.9.1 ## explicit; go 1.15 github.com/bytedance/sonic github.com/bytedance/sonic/ast @@ -94,6 +94,8 @@ github.com/bytedance/sonic/decoder github.com/bytedance/sonic/encoder github.com/bytedance/sonic/internal/caching github.com/bytedance/sonic/internal/cpu +github.com/bytedance/sonic/internal/decoder +github.com/bytedance/sonic/internal/encoder github.com/bytedance/sonic/internal/jit github.com/bytedance/sonic/internal/loader github.com/bytedance/sonic/internal/native @@ -193,8 +195,8 @@ github.com/gin-contrib/sessions/memstore # github.com/gin-contrib/sse v0.1.0 ## explicit; go 1.12 github.com/gin-contrib/sse -# github.com/gin-gonic/gin v1.9.0 -## explicit; go 1.18 +# github.com/gin-gonic/gin v1.9.1 +## explicit; go 1.20 github.com/gin-gonic/gin github.com/gin-gonic/gin/binding github.com/gin-gonic/gin/internal/bytesconv @@ -234,7 +236,7 @@ github.com/go-playground/validator/v10 # github.com/go-xmlfmt/xmlfmt v0.0.0-20211206191508-7fd73a941850 ## explicit github.com/go-xmlfmt/xmlfmt -# github.com/goccy/go-json v0.10.0 +# github.com/goccy/go-json v0.10.2 ## explicit; go 1.12 github.com/goccy/go-json github.com/goccy/go-json/internal/decoder @@ -371,7 +373,7 @@ github.com/leodido/go-urn # github.com/magiconair/properties v1.8.7 ## explicit; go 1.19 github.com/magiconair/properties -# github.com/mattn/go-isatty v0.0.18 +# github.com/mattn/go-isatty v0.0.19 ## explicit; go 1.15 github.com/mattn/go-isatty # github.com/microcosm-cc/bluemonday v1.0.24 @@ -415,7 +417,7 @@ github.com/oklog/ulid # github.com/opencontainers/runtime-spec v1.0.2 ## explicit github.com/opencontainers/runtime-spec/specs-go -# github.com/pelletier/go-toml/v2 v2.0.6 +# github.com/pelletier/go-toml/v2 v2.0.8 ## explicit; go 1.16 github.com/pelletier/go-toml/v2 github.com/pelletier/go-toml/v2/internal/characters @@ -709,7 +711,7 @@ github.com/twitchyliquid64/golang-asm/objabi github.com/twitchyliquid64/golang-asm/src github.com/twitchyliquid64/golang-asm/sys github.com/twitchyliquid64/golang-asm/unsafeheader -# github.com/ugorji/go/codec v1.2.9 +# github.com/ugorji/go/codec v1.2.11 ## explicit; go 1.11 github.com/ugorji/go/codec # github.com/ulule/limiter/v3 v3.11.2 @@ -829,7 +831,7 @@ go.opentelemetry.io/proto/otlp/trace/v1 go.uber.org/automaxprocs/internal/cgroups go.uber.org/automaxprocs/internal/runtime go.uber.org/automaxprocs/maxprocs -# golang.org/x/arch v0.0.0-20210923205945-b76863e36670 +# golang.org/x/arch v0.3.0 ## explicit; go 1.17 golang.org/x/arch/x86/x86asm # golang.org/x/crypto v0.9.0 |
